From: Yoan Picchi <yoan.picchi@foss.arm.com>
To: Konstantin Ananyev <konstantin.ananyev@huawei.com>,
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: Tue, 5 Mar 2024 15:36:13 +0000 [thread overview]
Message-ID: <185221ea-d933-4619-bd00-2d94224d646d@foss.arm.com> (raw)
In-Reply-To: <26ede8330c0b4c2cb213cdc7102d4e86@huawei.com>
On 3/4/24 13:35, Konstantin Ananyev wrote:
>
>
>>>> - 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...
>>>
>
> Hi, apologies for long delay in response.
>
>
>> I can easily enough move the compare_signatures into an arm/x86
>> directory, and have a default version in the code.
>
> Yes, that's what I thought about.
>
>> The problem would be for bulk lookup. The function is already duplicated
>> 2 times (the l and lf version). If I remove the #ifdefs, I'll need to
>> duplicate them again into 4 nearly identical versions (dense and
>> sparse). The only third options I see would be some preprocessor macro
>> to patch the function, but that looks even dirtier to me.
>
> Not sure I understood you here: from looking at the code I don't see any
> arch specific ifdefs in bulk_lookup() routines.
> What I am missing here?
>
Most if not all of those #if are architecture specific. For instance:
#if defined(__ARM_NEON)
#if defined(RTE_HAS_SVE_ACLE)
The main reason there's some #if in bulk lookup is to handle whether the
function run with dense hitmask or a sparse hitmask.
x86 only support the sparse hitmask version (1 bit data, 1 bit padding)
but arm support the dense hitmask (every bit count). The later ends up
being faster.
Splitting bulk_lookup into its sparse and dense variant would be a lot
of code duplication that I'd prefer to avoid.
What I might be able to do would be move compare_signatures into some
arch specific version. The function are different enough that it
wouldn't be too much of a code duplication. I'd argue though that the
#ifded for NEON and SSE were already there and I only added the SVE variant.
>
>> I think duplicating the code would be bad, but I can do it if you want.
>> Unless you have a better solution?
>>
>>>> +#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-03-05 15:36 UTC|newest]
Thread overview: 43+ 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
2024-02-28 14:48 ` Yoan Picchi
2024-03-04 13:35 ` Konstantin Ananyev
2024-03-05 15:36 ` Yoan Picchi [this message]
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-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
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=185221ea-d933-4619-bd00-2d94224d646d@foss.arm.com \
--to=yoan.picchi@foss.arm.com \
--cc=bruce.richardson@intel.com \
--cc=dev@dpdk.org \
--cc=harjot.singh@arm.com \
--cc=konstantin.ananyev@huawei.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).