From: Konstantin Ananyev <konstantin.ananyev@huawei.com>
To: Yoan Picchi <yoan.picchi@arm.com>,
Yipeng Wang <yipeng1.wang@intel.com>,
Sameh Gobriel <sameh.gobriel@intel.com>,
Bruce Richardson <bruce.richardson@intel.com>,
Vladimir Medvedkin <vladimir.medvedkin@intel.com>
Cc: "dev@dpdk.org" <dev@dpdk.org>, "nd@arm.com" <nd@arm.com>,
Harjot Singh <harjot.singh@arm.com>,
Nathan Brown <nathan.brown@arm.com>,
Ruifeng Wang <ruifeng.wang@arm.com>
Subject: RE: [PATCH v5 4/4] hash: add SVE support for bulk key lookup
Date: Wed, 28 Feb 2024 10:56:26 +0000 [thread overview]
Message-ID: <a6c022b63ad9493a9245f76bb398a0a5@huawei.com> (raw)
In-Reply-To: <20240227174203.2889333-5-yoan.picchi@arm.com>
>
> - Implemented SVE code for comparing signatures in bulk lookup.
> - Added Defines in code for SVE code support.
> - Optimise NEON code
> - New SVE code is ~5% slower than optimized NEON for N2 processor.
>
> Signed-off-by: Yoan Picchi <yoan.picchi@arm.com>
> Signed-off-by: Harjot Singh <harjot.singh@arm.com>
> Reviewed-by: Nathan Brown <nathan.brown@arm.com>
> Reviewed-by: Ruifeng Wang <ruifeng.wang@arm.com>
> ---
> lib/hash/rte_cuckoo_hash.c | 196 ++++++++++++++++++++++++++++---------
> lib/hash/rte_cuckoo_hash.h | 1 +
> 2 files changed, 151 insertions(+), 46 deletions(-)
>
> diff --git a/lib/hash/rte_cuckoo_hash.c b/lib/hash/rte_cuckoo_hash.c
> index a07dd3a28d..231d6d6ded 100644
> --- a/lib/hash/rte_cuckoo_hash.c
> +++ b/lib/hash/rte_cuckoo_hash.c
> @@ -442,8 +442,11 @@ rte_hash_create(const struct rte_hash_parameters *params)
> h->sig_cmp_fn = RTE_HASH_COMPARE_SSE;
> else
> #elif defined(RTE_ARCH_ARM64)
> - if (rte_cpu_get_flag_enabled(RTE_CPUFLAG_NEON))
> + if (rte_cpu_get_flag_enabled(RTE_CPUFLAG_NEON)) {
> h->sig_cmp_fn = RTE_HASH_COMPARE_NEON;
> + if (rte_cpu_get_flag_enabled(RTE_CPUFLAG_SVE))
> + h->sig_cmp_fn = RTE_HASH_COMPARE_SVE;
> + }
> else
> #endif
> h->sig_cmp_fn = RTE_HASH_COMPARE_SCALAR;
> @@ -1860,37 +1863,103 @@ rte_hash_free_key_with_position(const struct rte_hash *h,
> #if defined(__ARM_NEON)
>
> static inline void
> -compare_signatures_dense(uint32_t *prim_hash_matches, uint32_t *sec_hash_matches,
> - const struct rte_hash_bucket *prim_bkt,
> - const struct rte_hash_bucket *sec_bkt,
> +compare_signatures_dense(uint16_t *hitmask_buffer,
> + const uint16_t *prim_bucket_sigs,
> + const uint16_t *sec_bucket_sigs,
> uint16_t sig,
> enum rte_hash_sig_compare_function sig_cmp_fn)
> {
> unsigned int i;
>
> + static_assert(sizeof(*hitmask_buffer) >= 2*(RTE_HASH_BUCKET_ENTRIES/8),
> + "The hitmask must be exactly wide enough to accept the whole hitmask if it is dense");
> +
> /* For match mask every bits indicates the match */
> switch (sig_cmp_fn) {
Can I ask to move arch specific comparison code into some arch-specific headers or so?
It is getting really hard to read and understand the generic code with all these ifdefs and arch specific instructions...
> +#if RTE_HASH_BUCKET_ENTRIES <= 8
> case RTE_HASH_COMPARE_NEON: {
> - uint16x8_t vmat, x;
> + uint16x8_t vmat, hit1, hit2;
> const uint16x8_t mask = {0x1, 0x2, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80};
> const uint16x8_t vsig = vld1q_dup_u16((uint16_t const *)&sig);
>
> /* Compare all signatures in the primary bucket */
> - vmat = vceqq_u16(vsig, vld1q_u16((uint16_t const *)prim_bkt->sig_current));
> - x = vandq_u16(vmat, mask);
> - *prim_hash_matches = (uint32_t)(vaddvq_u16(x));
> + vmat = vceqq_u16(vsig, vld1q_u16(prim_bucket_sigs));
> + hit1 = vandq_u16(vmat, mask);
> +
> /* Compare all signatures in the secondary bucket */
> - vmat = vceqq_u16(vsig, vld1q_u16((uint16_t const *)sec_bkt->sig_current));
> - x = vandq_u16(vmat, mask);
> - *sec_hash_matches = (uint32_t)(vaddvq_u16(x));
> + vmat = vceqq_u16(vsig, vld1q_u16(sec_bucket_sigs));
> + hit2 = vandq_u16(vmat, mask);
> +
> + hit2 = vshlq_n_u16(hit2, RTE_HASH_BUCKET_ENTRIES);
> + hit2 = vorrq_u16(hit1, hit2);
> + *hitmask_buffer = vaddvq_u16(hit2);
> + }
> + break;
> +#endif
> +#if defined(RTE_HAS_SVE_ACLE)
> + case RTE_HASH_COMPARE_SVE: {
> + svuint16_t vsign, shift, sv_matches;
> + svbool_t pred, match, bucket_wide_pred;
> + int i = 0;
> + uint64_t vl = svcnth();
> +
> + vsign = svdup_u16(sig);
> + shift = svindex_u16(0, 1);
> +
> + if (vl >= 2 * RTE_HASH_BUCKET_ENTRIES && RTE_HASH_BUCKET_ENTRIES <= 8) {
> + svuint16_t primary_array_vect, secondary_array_vect;
> + bucket_wide_pred = svwhilelt_b16(0, RTE_HASH_BUCKET_ENTRIES);
> + primary_array_vect = svld1_u16(bucket_wide_pred, prim_bucket_sigs);
> + secondary_array_vect = svld1_u16(bucket_wide_pred, sec_bucket_sigs);
> +
> + /* We merged the two vectors so we can do both comparison at once */
> + primary_array_vect = svsplice_u16(bucket_wide_pred,
> + primary_array_vect,
> + secondary_array_vect);
> + pred = svwhilelt_b16(0, 2*RTE_HASH_BUCKET_ENTRIES);
> +
> + /* Compare all signatures in the buckets */
> + match = svcmpeq_u16(pred, vsign, primary_array_vect);
> + if (svptest_any(svptrue_b16(), match)) {
> + sv_matches = svdup_u16(1);
> + sv_matches = svlsl_u16_z(match, sv_matches, shift);
> + *hitmask_buffer = svorv_u16(svptrue_b16(), sv_matches);
> + }
> + } else {
> + do {
> + pred = svwhilelt_b16(i, RTE_HASH_BUCKET_ENTRIES);
> + uint16_t lower_half = 0;
> + uint16_t upper_half = 0;
> + /* Compare all signatures in the primary bucket */
> + match = svcmpeq_u16(pred, vsign, svld1_u16(pred,
> + &prim_bucket_sigs[i]));
> + if (svptest_any(svptrue_b16(), match)) {
> + sv_matches = svdup_u16(1);
> + sv_matches = svlsl_u16_z(match, sv_matches, shift);
> + lower_half = svorv_u16(svptrue_b16(), sv_matches);
> + }
> + /* Compare all signatures in the secondary bucket */
> + match = svcmpeq_u16(pred, vsign, svld1_u16(pred,
> + &sec_bucket_sigs[i]));
> + if (svptest_any(svptrue_b16(), match)) {
> + sv_matches = svdup_u16(1);
> + sv_matches = svlsl_u16_z(match, sv_matches, shift);
> + upper_half = svorv_u16(svptrue_b16(), sv_matches)
> + << RTE_HASH_BUCKET_ENTRIES;
> + }
> + hitmask_buffer[i/8] = upper_half | lower_half;
> + i += vl;
> + } while (i < RTE_HASH_BUCKET_ENTRIES);
> + }
> }
> break;
> +#endif
> default:
> for (i = 0; i < RTE_HASH_BUCKET_ENTRIES; i++) {
> - *prim_hash_matches |=
> - ((sig == prim_bkt->sig_current[i]) << i);
> - *sec_hash_matches |=
> - ((sig == sec_bkt->sig_current[i]) << i);
> + *hitmask_buffer |=
> + ((sig == prim_bucket_sigs[i]) << i);
> + *hitmask_buffer |=
> + ((sig == sec_bucket_sigs[i]) << i) << RTE_HASH_BUCKET_ENTRIES;
> }
> }
> }
> @@ -1908,7 +1977,7 @@ compare_signatures_sparse(uint32_t *prim_hash_matches, uint32_t *sec_hash_matche
>
> /* For match mask the first bit of every two bits indicates the match */
> switch (sig_cmp_fn) {
> -#if defined(__SSE2__)
> +#if defined(__SSE2__) && RTE_HASH_BUCKET_ENTRIES <= 8
> case RTE_HASH_COMPARE_SSE:
> /* Compare all signatures in the bucket */
> *prim_hash_matches = _mm_movemask_epi8(_mm_cmpeq_epi16(
> @@ -1948,14 +2017,18 @@ __bulk_lookup_l(const struct rte_hash *h, const void **keys,
> uint64_t hits = 0;
> int32_t i;
> int32_t ret;
> - 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;
>
> #if defined(__ARM_NEON)
> const int hitmask_padding = 0;
> + uint16_t hitmask_buffer[RTE_HASH_LOOKUP_BULK_MAX] = {0};
> +
> + static_assert(sizeof(*hitmask_buffer)*8/2 == RTE_HASH_BUCKET_ENTRIES,
> + "The hitmask must be exactly wide enough to accept the whole hitmask when it is dense");
> #else
> const int hitmask_padding = 1;
> + uint32_t prim_hitmask_buffer[RTE_HASH_LOOKUP_BULK_MAX] = {0};
> + uint32_t sec_hitmask_buffer[RTE_HASH_LOOKUP_BULK_MAX] = {0};
> #endif
>
> __hash_rw_reader_lock(h);
> @@ -1963,18 +2036,24 @@ __bulk_lookup_l(const struct rte_hash *h, const void **keys,
> /* Compare signatures and prefetch key slot of first hit */
> for (i = 0; i < num_keys; i++) {
> #if defined(__ARM_NEON)
> - compare_signatures_dense(&prim_hitmask[i], &sec_hitmask[i],
> - primary_bkt[i], secondary_bkt[i],
> + uint16_t *hitmask = &hitmask_buffer[i];
> + compare_signatures_dense(hitmask,
> + primary_bkt[i]->sig_current,
> + secondary_bkt[i]->sig_current,
> sig[i], h->sig_cmp_fn);
> + const unsigned int prim_hitmask = *(uint8_t *)(hitmask);
> + const unsigned int sec_hitmask = *((uint8_t *)(hitmask)+1);
> #else
> - compare_signatures_sparse(&prim_hitmask[i], &sec_hitmask[i],
> + compare_signatures_sparse(&prim_hitmask_buffer[i], &sec_hitmask_buffer[i],
> primary_bkt[i], secondary_bkt[i],
> sig[i], h->sig_cmp_fn);
> + const unsigned int prim_hitmask = prim_hitmask_buffer[i];
> + const unsigned int sec_hitmask = sec_hitmask_buffer[i];
> #endif
>
> - if (prim_hitmask[i]) {
> + if (prim_hitmask) {
> uint32_t first_hit =
> - rte_ctz32(prim_hitmask[i])
> + rte_ctz32(prim_hitmask)
> >> hitmask_padding;
> uint32_t key_idx =
> primary_bkt[i]->key_idx[first_hit];
> @@ -1986,9 +2065,9 @@ __bulk_lookup_l(const struct rte_hash *h, const void **keys,
> continue;
> }
>
> - if (sec_hitmask[i]) {
> + if (sec_hitmask) {
> uint32_t first_hit =
> - rte_ctz32(sec_hitmask[i])
> + rte_ctz32(sec_hitmask)
> >> hitmask_padding;
> uint32_t key_idx =
> secondary_bkt[i]->key_idx[first_hit];
> @@ -2003,9 +2082,17 @@ __bulk_lookup_l(const struct rte_hash *h, const void **keys,
> /* Compare keys, first hits in primary first */
> for (i = 0; i < num_keys; i++) {
> positions[i] = -ENOENT;
> - while (prim_hitmask[i]) {
> +#if defined(__ARM_NEON)
> + uint16_t *hitmask = &hitmask_buffer[i];
> + unsigned int prim_hitmask = *(uint8_t *)(hitmask);
> + unsigned int sec_hitmask = *((uint8_t *)(hitmask)+1);
> +#else
> + unsigned int prim_hitmask = prim_hitmask_buffer[i];
> + unsigned int sec_hitmask = sec_hitmask_buffer[i];
> +#endif
> + while (prim_hitmask) {
> uint32_t hit_index =
> - rte_ctz32(prim_hitmask[i])
> + rte_ctz32(prim_hitmask)
> >> hitmask_padding;
> uint32_t key_idx =
> primary_bkt[i]->key_idx[hit_index];
> @@ -2028,12 +2115,12 @@ __bulk_lookup_l(const struct rte_hash *h, const void **keys,
> positions[i] = key_idx - 1;
> goto next_key;
> }
> - prim_hitmask[i] &= ~(1 << (hit_index << hitmask_padding));
> + prim_hitmask &= ~(1 << (hit_index << hitmask_padding));
> }
>
> - while (sec_hitmask[i]) {
> + while (sec_hitmask) {
> uint32_t hit_index =
> - rte_ctz32(sec_hitmask[i])
> + rte_ctz32(sec_hitmask)
> >> hitmask_padding;
> uint32_t key_idx =
> secondary_bkt[i]->key_idx[hit_index];
> @@ -2057,7 +2144,7 @@ __bulk_lookup_l(const struct rte_hash *h, const void **keys,
> positions[i] = key_idx - 1;
> goto next_key;
> }
> - sec_hitmask[i] &= ~(1 << (hit_index << hitmask_padding));
> + sec_hitmask &= ~(1 << (hit_index << hitmask_padding));
> }
> next_key:
> continue;
> @@ -2107,15 +2194,18 @@ __bulk_lookup_lf(const struct rte_hash *h, const void **keys,
> uint64_t hits = 0;
> int32_t i;
> int32_t ret;
> - 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;
>
> #if defined(__ARM_NEON)
> const int hitmask_padding = 0;
> + uint16_t hitmask_buffer[RTE_HASH_LOOKUP_BULK_MAX] = {0};
> + static_assert(sizeof(*hitmask_buffer)*8/2 == RTE_HASH_BUCKET_ENTRIES,
> + "The hitmask must be exactly wide enough to accept the whole hitmask chen it is dense");
> #else
> const int hitmask_padding = 1;
> + uint32_t prim_hitmask_buffer[RTE_HASH_LOOKUP_BULK_MAX] = {0};
> + uint32_t sec_hitmask_buffer[RTE_HASH_LOOKUP_BULK_MAX] = {0};
> #endif
>
> for (i = 0; i < num_keys; i++)
> @@ -2132,18 +2222,24 @@ __bulk_lookup_lf(const struct rte_hash *h, const void **keys,
> /* Compare signatures and prefetch key slot of first hit */
> for (i = 0; i < num_keys; i++) {
> #if defined(__ARM_NEON)
> - compare_signatures_dense(&prim_hitmask[i], &sec_hitmask[i],
> - primary_bkt[i], secondary_bkt[i],
> + uint16_t *hitmask = &hitmask_buffer[i];
> + compare_signatures_dense(hitmask,
> + primary_bkt[i]->sig_current,
> + secondary_bkt[i]->sig_current,
> sig[i], h->sig_cmp_fn);
> + const unsigned int prim_hitmask = *(uint8_t *)(hitmask);
> + const unsigned int sec_hitmask = *((uint8_t *)(hitmask)+1);
> #else
> - compare_signatures_sparse(&prim_hitmask[i], &sec_hitmask[i],
> + compare_signatures_sparse(&prim_hitmask_buffer[i], &sec_hitmask_buffer[i],
> primary_bkt[i], secondary_bkt[i],
> sig[i], h->sig_cmp_fn);
> + const unsigned int prim_hitmask = prim_hitmask_buffer[i];
> + const unsigned int sec_hitmask = sec_hitmask_buffer[i];
> #endif
>
> - if (prim_hitmask[i]) {
> + if (prim_hitmask) {
> uint32_t first_hit =
> - rte_ctz32(prim_hitmask[i])
> + rte_ctz32(prim_hitmask)
> >> hitmask_padding;
> uint32_t key_idx =
> primary_bkt[i]->key_idx[first_hit];
> @@ -2155,9 +2251,9 @@ __bulk_lookup_lf(const struct rte_hash *h, const void **keys,
> continue;
> }
>
> - if (sec_hitmask[i]) {
> + if (sec_hitmask) {
> uint32_t first_hit =
> - rte_ctz32(sec_hitmask[i])
> + rte_ctz32(sec_hitmask)
> >> hitmask_padding;
> uint32_t key_idx =
> secondary_bkt[i]->key_idx[first_hit];
> @@ -2171,9 +2267,17 @@ __bulk_lookup_lf(const struct rte_hash *h, const void **keys,
>
> /* Compare keys, first hits in primary first */
> for (i = 0; i < num_keys; i++) {
> - while (prim_hitmask[i]) {
> +#if defined(__ARM_NEON)
> + uint16_t *hitmask = &hitmask_buffer[i];
> + unsigned int prim_hitmask = *(uint8_t *)(hitmask);
> + unsigned int sec_hitmask = *((uint8_t *)(hitmask)+1);
> +#else
> + unsigned int prim_hitmask = prim_hitmask_buffer[i];
> + unsigned int sec_hitmask = sec_hitmask_buffer[i];
> +#endif
> + while (prim_hitmask) {
> uint32_t hit_index =
> - rte_ctz32(prim_hitmask[i])
> + rte_ctz32(prim_hitmask)
> >> hitmask_padding;
> uint32_t key_idx =
> rte_atomic_load_explicit(
> @@ -2200,12 +2304,12 @@ __bulk_lookup_lf(const struct rte_hash *h, const void **keys,
> positions[i] = key_idx - 1;
> goto next_key;
> }
> - prim_hitmask[i] &= ~(1 << (hit_index << hitmask_padding));
> + prim_hitmask &= ~(1 << (hit_index << hitmask_padding));
> }
>
> - while (sec_hitmask[i]) {
> + while (sec_hitmask) {
> uint32_t hit_index =
> - rte_ctz32(sec_hitmask[i])
> + rte_ctz32(sec_hitmask)
> >> hitmask_padding;
> uint32_t key_idx =
> rte_atomic_load_explicit(
> @@ -2233,7 +2337,7 @@ __bulk_lookup_lf(const struct rte_hash *h, const void **keys,
> positions[i] = key_idx - 1;
> goto next_key;
> }
> - sec_hitmask[i] &= ~(1 << (hit_index << hitmask_padding));
> + sec_hitmask &= ~(1 << (hit_index << hitmask_padding));
> }
> next_key:
> continue;
> diff --git a/lib/hash/rte_cuckoo_hash.h b/lib/hash/rte_cuckoo_hash.h
> index 8ea793c66e..ed18e1f41e 100644
> --- a/lib/hash/rte_cuckoo_hash.h
> +++ b/lib/hash/rte_cuckoo_hash.h
> @@ -137,6 +137,7 @@ enum rte_hash_sig_compare_function {
> RTE_HASH_COMPARE_SCALAR = 0,
> RTE_HASH_COMPARE_SSE,
> RTE_HASH_COMPARE_NEON,
> + RTE_HASH_COMPARE_SVE,
> RTE_HASH_COMPARE_NUM
> };
>
> --
> 2.34.1
next prev parent reply other threads:[~2024-02-28 10:56 UTC|newest]
Thread overview: 73+ messages / expand[flat|nested] mbox.gz Atom feed top
2023-10-20 16:51 [PATCH v2 0/4] " Yoan Picchi
2023-10-20 16:51 ` [PATCH v2 1/4] hash: pack the hitmask for hash in bulk lookup Yoan Picchi
2023-10-20 16:51 ` [PATCH v2 2/4] hash: optimize compare signature for NEON Yoan Picchi
2023-10-20 16:51 ` [PATCH v2 3/4] test/hash: check bulk lookup of keys after collision Yoan Picchi
2023-10-20 16:51 ` [PATCH v2 4/4] hash: add SVE support for bulk key lookup Yoan Picchi
2024-02-27 17:41 ` [PATCH v5 0/4] " Yoan Picchi
2024-02-27 17:42 ` [PATCH v5 1/4] hash: pack the hitmask for hash in bulk lookup Yoan Picchi
2024-02-27 17:42 ` [PATCH v5 2/4] hash: optimize compare signature for NEON Yoan Picchi
2024-02-27 17:42 ` [PATCH v5 3/4] test/hash: check bulk lookup of keys after collision Yoan Picchi
2024-02-27 17:42 ` [PATCH v5 4/4] hash: add SVE support for bulk key lookup Yoan Picchi
2024-02-28 10:56 ` Konstantin Ananyev [this message]
2024-02-28 14:48 ` Yoan Picchi
2024-03-04 13:35 ` Konstantin Ananyev
2024-03-05 15:36 ` Yoan Picchi
2024-03-11 23:21 ` [PATCH v6 0/4] " Yoan Picchi
2024-03-11 23:21 ` [PATCH v6 1/4] hash: pack the hitmask for hash in bulk lookup Yoan Picchi
2024-03-11 23:21 ` [PATCH v6 2/4] hash: optimize compare signature for NEON Yoan Picchi
2024-03-11 23:21 ` [PATCH v6 3/4] test/hash: check bulk lookup of keys after collision Yoan Picchi
2024-03-11 23:21 ` [PATCH v6 4/4] hash: add SVE support for bulk key lookup Yoan Picchi
2024-03-12 3:57 ` fengchengwen
2024-03-12 15:08 ` Yoan Picchi
2024-03-12 15:42 ` [PATCH v7 0/4] " Yoan Picchi
2024-03-12 15:42 ` [PATCH v7 1/4] hash: pack the hitmask for hash in bulk lookup Yoan Picchi
2024-03-19 10:41 ` Konstantin Ananyev
2024-03-19 13:09 ` Yoan Picchi
2024-03-19 13:25 ` Konstantin Ananyev
2024-03-19 16:09 ` Stephen Hemminger
2024-03-12 15:42 ` [PATCH v7 2/4] hash: optimize compare signature for NEON Yoan Picchi
2024-03-20 7:37 ` [EXTERNAL] " Pavan Nikhilesh Bhagavatula
2024-04-11 13:32 ` Yoan Picchi
2024-03-12 15:42 ` [PATCH v7 3/4] test/hash: check bulk lookup of keys after collision Yoan Picchi
2024-03-12 15:42 ` [PATCH v7 4/4] hash: add SVE support for bulk key lookup Yoan Picchi
2024-04-17 16:08 ` [PATCH v8 0/4] " Yoan Picchi
2024-04-17 16:08 ` [PATCH v8 1/4] hash: pack the hitmask for hash in bulk lookup Yoan Picchi
2024-04-17 18:12 ` Stephen Hemminger
2024-04-17 16:08 ` [PATCH v8 2/4] hash: optimize compare signature for NEON Yoan Picchi
2024-04-17 16:08 ` [PATCH v8 3/4] test/hash: check bulk lookup of keys after collision Yoan Picchi
2024-04-17 16:08 ` [PATCH v8 4/4] hash: add SVE support for bulk key lookup Yoan Picchi
2024-04-30 16:27 ` [PATCH v9 0/4] " Yoan Picchi
2024-04-30 16:27 ` [PATCH v9 1/4] hash: pack the hitmask for hash in bulk lookup Yoan Picchi
2024-06-14 13:42 ` David Marchand
2024-04-30 16:27 ` [PATCH v9 2/4] hash: optimize compare signature for NEON Yoan Picchi
2024-04-30 16:27 ` [PATCH v9 3/4] test/hash: check bulk lookup of keys after collision Yoan Picchi
2024-04-30 16:27 ` [PATCH v9 4/4] hash: add SVE support for bulk key lookup Yoan Picchi
2024-06-14 13:42 ` David Marchand
2024-06-14 13:43 ` [PATCH v9 0/4] " David Marchand
2024-06-18 15:55 ` Konstantin Ananyev
2024-06-27 14:48 ` Thomas Monjalon
2024-07-03 17:13 ` [PATCH v10 " Yoan Picchi
2024-07-03 17:13 ` [PATCH v10 1/4] hash: pack the hitmask for hash in bulk lookup Yoan Picchi
2024-07-04 20:31 ` David Marchand
2024-07-05 17:43 ` Yoan Picchi
2024-07-07 12:08 ` Thomas Monjalon
2024-07-03 17:13 ` [PATCH v10 2/4] hash: optimize compare signature for NEON Yoan Picchi
2024-07-03 17:13 ` [PATCH v10 3/4] test/hash: check bulk lookup of keys after collision Yoan Picchi
2024-07-03 17:13 ` [PATCH v10 4/4] hash: add SVE support for bulk key lookup Yoan Picchi
2024-07-05 17:45 ` [PATCH v11 0/7] " Yoan Picchi
2024-07-05 17:45 ` [PATCH v11 1/7] hash: make compare signature function enum private Yoan Picchi
2024-07-05 17:45 ` [PATCH v11 2/7] hash: split compare signature into arch-specific files Yoan Picchi
2024-07-05 17:45 ` [PATCH v11 3/7] hash: add a check on hash entry max size Yoan Picchi
2024-07-05 17:45 ` [PATCH v11 4/7] hash: pack the hitmask for hash in bulk lookup Yoan Picchi
2024-07-05 17:45 ` [PATCH v11 5/7] hash: optimize compare signature for NEON Yoan Picchi
2024-07-05 17:45 ` [PATCH v11 6/7] test/hash: check bulk lookup of keys after collision Yoan Picchi
2024-07-05 17:45 ` [PATCH v11 7/7] hash: add SVE support for bulk key lookup Yoan Picchi
2024-07-08 12:14 ` [PATCH v12 0/7] " Yoan Picchi
2024-07-08 12:14 ` [PATCH v12 1/7] hash: make compare signature function enum private Yoan Picchi
2024-07-08 12:14 ` [PATCH v12 2/7] hash: split compare signature into arch-specific files Yoan Picchi
2024-07-08 12:14 ` [PATCH v12 3/7] hash: add a check on hash entry max size Yoan Picchi
2024-07-08 12:14 ` [PATCH v12 4/7] hash: pack the hitmask for hash in bulk lookup Yoan Picchi
2024-07-08 12:14 ` [PATCH v12 5/7] hash: optimize compare signature for NEON Yoan Picchi
2024-07-08 12:14 ` [PATCH v12 6/7] test/hash: check bulk lookup of keys after collision Yoan Picchi
2024-07-08 12:14 ` [PATCH v12 7/7] hash: add SVE support for bulk key lookup Yoan Picchi
2024-07-09 4:48 ` [PATCH v12 0/7] " David Marchand
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=a6c022b63ad9493a9245f76bb398a0a5@huawei.com \
--to=konstantin.ananyev@huawei.com \
--cc=bruce.richardson@intel.com \
--cc=dev@dpdk.org \
--cc=harjot.singh@arm.com \
--cc=nathan.brown@arm.com \
--cc=nd@arm.com \
--cc=ruifeng.wang@arm.com \
--cc=sameh.gobriel@intel.com \
--cc=vladimir.medvedkin@intel.com \
--cc=yipeng1.wang@intel.com \
--cc=yoan.picchi@arm.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).