lpm: add a scalar version of lookupx4 function
PATCH 1/1 lpm: add a scalar version of lookupx4 function
From: Michal Mazurek <[email protected]>
Add an implementation of the rte_lpm_lookupx4() function for platforms without support for vector operations.
This will be useful in the upcoming RISC-V port as well as any platform which may want to start with a basic level of LPM support.
--- doc/guides/rel_notes/release_22_07.rst | 5 + lib/lpm/meson.build | 1 + lib/lpm/rte_lpm.h | 4 +- lib/lpm/rte_lpm_scalar.h | 122 +++++++++++++++++++++++++ 4 files changed, 131 insertions(+), 1 deletion(-) create mode 100644 lib/lpm/rte_lpm_scalar.h
doc/guides/rel_notes/release_22_07.rst +5 -0
@@ -70,6 +70,11 @@ New Features * Added AH mode support in lookaside protocol (IPsec) for CN9K & CN10K. * Added AES-GMAC support in lookaside protocol (IPsec) for CN9K & CN10K. +* **Added scalar version of the LPM library.** + + * Added scalar implementation of ``rte_lpm_lookupx4``. This is a fall-back + implementation for platforms that don't support vector operations. + Removed Items -------------
lib/lpm/meson.build +1 -0
@@ -14,6 +14,7 @@ headers = files('rte_lpm.h', 'rte_lpm6.h') indirect_headers += files( 'rte_lpm_altivec.h', 'rte_lpm_neon.h', + 'rte_lpm_scalar.h', 'rte_lpm_sse.h', 'rte_lpm_sve.h', )
lib/lpm/rte_lpm.h +3 -1
@@ -405,8 +405,10 @@ rte_lpm_lookupx4(const struct rte_lpm *lpm, xmm_t ip, uint32_t hop[4],#endif #elif defined(RTE_ARCH_PPC_64 )#include "rte_lpm_altivec.h" -#else +#elif defined(RTE_ARCH_X86 )#include "rte_lpm_sse.h" +#else +#include "rte_lpm_scalar.h" #endif #ifdef __cplusplus
lib/lpm/rte_lpm_scalar.h new file +122 -0
122 lines not on this page · raw message
Signature · 1 line
2.30.2
Hi Stanislaw, Michal,
As far as I can see, this implementation almost completely repeats other lookupx4() implementations, except for the use of vector instructions.
On my board (x86_64) in lpm_perf_autotest your implementation takes about:
LPM LookupX4: 29.5 cycles (fails = 12.5%)
replacing this code with a simple loop with rte_lpm_lookup():
uint32_t nh;
int i, ret;
for (i = 0; i < 4; i++) {
ret = rte_lpm_lookup((struct rte_lpm *)lpm, ((rte_xmm_t)ip).u32[i], &nh); hop[i] = (ret == 0) ? nh : defv;
}
works faster:
LPM LookupX4: 22.2 cycles (fails = 12.5%)
I'm wondering if this will work faster on your board (I assume it it RISC-V arch)?
Thanks!
Quoted 190 lines · Stanislaw Kardach
From: Michal Mazurek <[email protected]>
Add an implementation of the
rte_lpm_lookupx4()function for platforms without support for vector operations.This will be useful in the upcoming RISC-V port as well as any platform which may want to start with a basic level of LPM support.
Signed-off-by Michal Mazurek <[email protected]>Signed-off-by Stanislaw Kardach <[email protected]>--- doc/guides/rel_notes/release_22_07.rst | 5 + lib/lpm/meson.build | 1 + lib/lpm/rte_lpm.h | 4 +- lib/lpm/rte_lpm_scalar.h | 122 +++++++++++++++++++++++++ 4 files changed, 131 insertions(+), 1 deletion(-)create mode 100644
lib/lpm/rte_lpm_scalar.hdoc/guides/rel_notes/release_22_07.rst +5
-0@@ -70,6 +70,11 @@ New Features * Added AH mode support in lookaside protocol (IPsec) for CN9K & CN10K. * Added AES-GMAC support in lookaside protocol (IPsec) for CN9K & CN10K. +* **Added scalar version of the LPM library.** + + * Added scalar implementation of ``rte_lpm_lookupx4``. This is a fall-back + implementation for platforms that don't support vector operations. + Removed Items -------------lib/lpm/meson.build +1
-0@@ -14,6 +14,7 @@ headers = files('rte_lpm.h', 'rte_lpm6.h') indirect_headers += files( 'rte_lpm_altivec.h', 'rte_lpm_neon.h', + 'rte_lpm_scalar.h', 'rte_lpm_sse.h', 'rte_lpm_sve.h', )lib/lpm/rte_lpm.h +3
-1@@ -405,8 +405,10 @@ rte_lpm_lookupx4(const struct rte_lpm *lpm, xmm_t ip, uint32_t hop[4],#endif #elif defined(RTE_ARCH_PPC_64 )#include "rte_lpm_altivec.h" -#else +#elif defined(RTE_ARCH_X86 )#include "rte_lpm_sse.h" +#else +#include "rte_lpm_scalar.h" #endif #ifdef __cpluspluslib/lpm/rte_lpm_scalar.h new file +122
-0@@ -0,0 +1,122 @@ +/* SPDX-License-Identifier: BSD-3-Clause +* Copyright(c) 2022 StarFive +* Copyright(c) 2022 SiFive +* Copyright(c) 2022 Semihalf +*/ + +#ifndef _RTE_LPM_SCALAR_H_ +#define _RTE_LPM_SCALAR_H_ + +#include <rte_branch_prediction.h> +#include <rte_byteorder.h> +#include <rte_common.h> +#include <rte_vect.h> + +#ifdef __cplusplus +extern "C" { +#endif + +static inline void +rte_lpm_lookupx4 (const struct rte_lpm *lpm,xmm_t ip,uint32_t hop[4 ], +uint32_t defv) +{ +rte_xmm_t i24; +rte_xmm_t i8; +uint32_t tbl[4 ]; +uint64_t pt, pt2; +const uint32_t *ptbl; + +const rte_xmm_t mask8 = { + .u32 = {UINT8_MAX ,UINT8_MAX ,UINT8_MAX ,UINT8_MAX }}; + +/* +* RTE_LPM_VALID_EXT_ENTRY_BITMASK for 2 LPM entries +* as one 64-bit value (0x0300000003000000). +*/ +const uint64_t mask_xv = + ((uint64_t )RTE_LPM_VALID_EXT_ENTRY_BITMASK | + (uint64_t )RTE_LPM_VALID_EXT_ENTRY_BITMASK <<32 ); + +/* +* RTE_LPM_LOOKUP_SUCCESS for 2 LPM entries +* as one 64-bit value (0x0100000001000000). +*/ +const uint64_t mask_v = + ((uint64_t )RTE_LPM_LOOKUP_SUCCESS | + (uint64_t )RTE_LPM_LOOKUP_SUCCESS <<32 ); + +/* get 4 indexes for tbl24[]. */ + i24.x = ip; + i24.u32[0 ] >>=CHAR_BIT ; + i24.u32[1 ] >>=CHAR_BIT ; + i24.u32[2 ] >>=CHAR_BIT ; + i24.u32[3 ] >>=CHAR_BIT ; + +/* extract values from tbl24[] */ + ptbl = (const uint32_t *)&lpm->tbl24[i24.u32[0 ]]; + tbl[0 ] = *ptbl; + ptbl = (const uint32_t *)&lpm->tbl24[i24.u32[1 ]]; + tbl[1 ] = *ptbl; + ptbl = (const uint32_t *)&lpm->tbl24[i24.u32[2 ]]; + tbl[2 ] = *ptbl; + ptbl = (const uint32_t *)&lpm->tbl24[i24.u32[3 ]]; + tbl[3 ] = *ptbl; + +/* get 4 indexes for tbl8[]. */ + i8.x = ip; + i8.u64[0 ] &= mask8.u64[0 ]; + i8.u64[1 ] &= mask8.u64[1 ]; + + pt = (uint64_t )tbl[0 ] | + (uint64_t )tbl[1 ] <<32 ; + pt2 = (uint64_t )tbl[2 ] | + (uint64_t )tbl[3 ] <<32 ; + +/* search successfully finished for all 4 IP addresses. */ +if (likely ((pt & mask_xv) == mask_v) && +likely ((pt2 & mask_xv) == mask_v)) { + *(uint64_t *)hop = pt &RTE_LPM_MASKX4_RES ; + *(uint64_t *)(hop +2 ) = pt2 &RTE_LPM_MASKX4_RES ; +return ; + } + +if (unlikely ((pt &RTE_LPM_VALID_EXT_ENTRY_BITMASK ) == +RTE_LPM_VALID_EXT_ENTRY_BITMASK )) { + i8.u32[0 ] = i8.u32[0 ] + + (tbl[0 ] &0x00FFFFFF ) *RTE_LPM_TBL8_GROUP_NUM_ENTRIES ; + ptbl = (const uint32_t *)&lpm->tbl8[i8.u32[0 ]]; + tbl[0 ] = *ptbl; + } +if (unlikely ((pt >>32 &RTE_LPM_VALID_EXT_ENTRY_BITMASK ) == +RTE_LPM_VALID_EXT_ENTRY_BITMASK )) { + i8.u32[1 ] = i8.u32[1 ] + + (tbl[1 ] &0x00FFFFFF ) *RTE_LPM_TBL8_GROUP_NUM_ENTRIES ; + ptbl = (const uint32_t *)&lpm->tbl8[i8.u32[1 ]]; + tbl[1 ] = *ptbl; + } +if (unlikely ((pt2 &RTE_LPM_VALID_EXT_ENTRY_BITMASK ) == +RTE_LPM_VALID_EXT_ENTRY_BITMASK )) { + i8.u32[2 ] = i8.u32[2 ] + + (tbl[2 ] &0x00FFFFFF ) *RTE_LPM_TBL8_GROUP_NUM_ENTRIES ; + ptbl = (const uint32_t *)&lpm->tbl8[i8.u32[2 ]]; + tbl[2 ] = *ptbl; + } +if (unlikely ((pt2 >>32 &RTE_LPM_VALID_EXT_ENTRY_BITMASK ) == +RTE_LPM_VALID_EXT_ENTRY_BITMASK )) { + i8.u32[3 ] = i8.u32[3 ] + + (tbl[3 ] &0x00FFFFFF ) *RTE_LPM_TBL8_GROUP_NUM_ENTRIES ; + ptbl = (const uint32_t *)&lpm->tbl8[i8.u32[3 ]]; + tbl[3 ] = *ptbl; + } + + hop[0 ] = (tbl[0 ] &RTE_LPM_LOOKUP_SUCCESS ) ? tbl[0 ] &0x00FFFFFF : defv; + hop[1 ] = (tbl[1 ] &RTE_LPM_LOOKUP_SUCCESS ) ? tbl[1 ] &0x00FFFFFF : defv; + hop[2 ] = (tbl[2 ] &RTE_LPM_LOOKUP_SUCCESS ) ? tbl[2 ] &0x00FFFFFF : defv; + hop[3 ] = (tbl[3 ] &RTE_LPM_LOOKUP_SUCCESS ) ? tbl[3 ] &0x00FFFFFF : defv; +} + +#ifdef __cplusplus +} +#endif + +#endif /* _RTE_LPM_SCALAR_H_ */
Signature · 2 lines
Regards, Vladimir
Quoted 19 lines · Vladimir
Hi Stanislaw, Michal,
As far as I can see, this implementation almost completely repeats other
lookupx4()implementations, except for the use of vector instructions.On my board (
x86_64) inlpm_perf_autotestyour implementation takes about:
LPM LookupX4: 29.5 cycles (fails = 12.5%)replacing this code with a simple loop with
rte_lpm_lookup():
uint32_tnh;
int i, ret;for (i = 0; i < 4; i++) { ret = rte_lpm_lookup((struct rte_lpm *)lpm, ((rte_xmm_t)ip).u32[i], &nh); hop[i] = (ret == 0) ? nh : defv; }
Quoted 5 lines
works faster:
LPM LookupX4: 22.2 cycles (fails = 12.5%)I'm wondering if this will work faster on your board (I assume it it RISC-V arch)?
Hi Vladimir,
On my HiFive Unmatched RISC-V board there is a marginal difference (~ -1.56%):
Our version: 210.5 cycles (fails = 12.5%)
rte_lpm_lookup version: 213.8 cycles (fails = 12.5%)
Given that x86 is faster with rte_lpm_lookup, I'll change to this implementation in the next version.
That said I wonder why do we have different const requirements for rte_lpm_lookup() and rte_lpm_lookupx4():
static inline int rte_lpm_lookup(struct rte_lpm *lpm, uint32_t ip,uint32_t *next_hop)
static inline void rte_lpm_lookupx4(const struct rte_lpm *lpm, xmm_t
ip, uint32_t hop[4], uint32_t defv);
I think both should be const.
Quoted 198 lines
Thanks!
Quoted 180 lines · Stanislaw Kardach
From: Michal Mazurek <[email protected]>
Add an implementation of the
rte_lpm_lookupx4()function for platforms without support for vector operations.This will be useful in the upcoming RISC-V port as well as any platform which may want to start with a basic level of LPM support.
Signed-off-by Michal Mazurek <[email protected]>Signed-off-by Stanislaw Kardach <[email protected]>--- doc/guides/rel_notes/release_22_07.rst | 5 + lib/lpm/meson.build | 1 + lib/lpm/rte_lpm.h | 4 +- lib/lpm/rte_lpm_scalar.h | 122 +++++++++++++++++++++++++ 4 files changed, 131 insertions(+), 1 deletion(-)create mode 100644
lib/lpm/rte_lpm_scalar.hdoc/guides/rel_notes/release_22_07.rst +5
-0@@ -70,6 +70,11 @@ New Features * Added AH mode support in lookaside protocol (IPsec) for CN9K & CN10K. * Added AES-GMAC support in lookaside protocol (IPsec) for CN9K & CN10K. +* **Added scalar version of the LPM library.** + + * Added scalar implementation of ``rte_lpm_lookupx4``. This is a fall-back + implementation for platforms that don't support vector operations. + Removed Items -------------lib/lpm/meson.build +1
-0@@ -14,6 +14,7 @@ headers = files('rte_lpm.h', 'rte_lpm6.h') indirect_headers += files( 'rte_lpm_altivec.h', 'rte_lpm_neon.h', + 'rte_lpm_scalar.h', 'rte_lpm_sse.h', 'rte_lpm_sve.h', )lib/lpm/rte_lpm.h +3
-1@@ -405,8 +405,10 @@ rte_lpm_lookupx4(const struct rte_lpm *lpm, xmm_t ip, uint32_t hop[4],#endif #elif defined(RTE_ARCH_PPC_64 )#include "rte_lpm_altivec.h" -#else +#elif defined(RTE_ARCH_X86 )#include "rte_lpm_sse.h" +#else +#include "rte_lpm_scalar.h" #endif #ifdef __cpluspluslib/lpm/rte_lpm_scalar.h new file +112
-0@@ -0,0 +1,122 @@ +/* SPDX-License-Identifier: BSD-3-Clause +* Copyright(c) 2022 StarFive +* Copyright(c) 2022 SiFive +* Copyright(c) 2022 Semihalf +*/ + +#ifndef _RTE_LPM_SCALAR_H_ +#define _RTE_LPM_SCALAR_H_ + +#include <rte_branch_prediction.h> +#include <rte_byteorder.h> +#include <rte_common.h> +#include <rte_vect.h> + +#ifdef __cplusplus +extern "C" { +#endif + +static inline void +rte_lpm_lookupx4(const struct rte_lpm *lpm, xmm_t ip, uint32_t hop[4], + uint32_t defv) +{ + rte_xmm_t i24; + rte_xmm_t i8; + uint32_t tbl[4]; + uint64_t pt, pt2; + const uint32_t *ptbl; + + const rte_xmm_t mask8 = { + .u32 = {UINT8_MAX, UINT8_MAX, UINT8_MAX, UINT8_MAX}}; + + /* + * RTE_LPM_VALID_EXT_ENTRY_BITMASK for 2 LPM entries + * as one 64-bit value (0x0300000003000000). + */ + const uint64_t mask_xv = + ((uint64_t)RTE_LPM_VALID_EXT_ENTRY_BITMASK | + (uint64_t)RTE_LPM_VALID_EXT_ENTRY_BITMASK << 32); + + /* + * RTE_LPM_LOOKUP_SUCCESS for 2 LPM entries + * as one 64-bit value (0x0100000001000000). + */ + const uint64_t mask_v = + ((uint64_t)RTE_LPM_LOOKUP_SUCCESS | + (uint64_t)RTE_LPM_LOOKUP_SUCCESS << 32); + + /* get 4 indexes for tbl24[]. */ + i24.x = ip; + i24.u32[0] >>= CHAR_BIT; + i24.u32[1] >>= CHAR_BIT; + i24.u32[2] >>= CHAR_BIT; + i24.u32[3] >>= CHAR_BIT; + + /* extract values from tbl24[] */ + ptbl = (const uint32_t *)&lpm->tbl24[i24.u32[0]]; + tbl[0] = *ptbl; + ptbl = (const uint32_t *)&lpm->tbl24[i24.u32[1]]; + tbl[1] = *ptbl; + ptbl = (const uint32_t *)&lpm->tbl24[i24.u32[2]]; + tbl[2] = *ptbl; + ptbl = (const uint32_t *)&lpm->tbl24[i24.u32[3]]; + tbl[3] = *ptbl; + + /* get 4 indexes for tbl8[]. */ + i8.x = ip; + i8.u64[0] &= mask8.u64[0]; + i8.u64[1] &= mask8.u64[1]; + + pt = (uint64_t)tbl[0] | + (uint64_t)tbl[1] << 32; + pt2 = (uint64_t)tbl[2] | + (uint64_t)tbl[3] << 32; + + /* search successfully finished for all 4 IP addresses. */ + if (likely((pt & mask_xv) == mask_v) && + likely((pt2 & mask_xv) == mask_v)) { + *(uint64_t *)hop = pt & RTE_LPM_MASKX4_RES; + *(uint64_t *)(hop + 2) = pt2 & RTE_LPM_MASKX4_RES; + return; + } + + if (unlikely((pt & RTE_LPM_VALID_EXT_ENTRY_BITMASK) == + RTE_LPM_VALID_EXT_ENTRY_BITMASK)) { + i8.u32[0] = i8.u32[0] + + (tbl[0] & 0x00FFFFFF) * RTE_LPM_TBL8_GROUP_NUM_ENTRIES; + ptbl = (const uint32_t *)&lpm->tbl8[i8.u32[0]]; + tbl[0] = *ptbl; + } + if (unlikely((pt >> 32 & RTE_LPM_VALID_EXT_ENTRY_BITMASK) == + RTE_LPM_VALID_EXT_ENTRY_BITMASK)) { + i8.u32[1] = i8.u32[1] + + (tbl[1] & 0x00FFFFFF) * RTE_LPM_TBL8_GROUP_NUM_ENTRIES; + ptbl = (const uint32_t *)&lpm->tbl8[i8.u32[1]]; + tbl[1] = *ptbl; + } + if (unlikely((pt2 & RTE_LPM_VALID_EXT_ENTRY_BITMASK) == + RTE_LPM_VALID_EXT_ENTRY_BITMASK)) { + i8.u32[2] = i8.u32[2] + + (tbl[2] & 0x00FFFFFF) * RTE_LPM_TBL8_GROUP_NUM_ENTRIES; + ptbl = (const uint32_t *)&lpm->tbl8[i8.u32[2]]; + tbl[2] = *ptbl; + } + if (unlikely((pt2 >> 32 & RTE_LPM_VALID_EXT_ENTRY_BITMASK) == + RTE_LPM_VALID_EXT_ENTRY_BITMASK)) { + i8.u32[3] = i8.u32[3] + + (tbl[3] & 0x00FFFFFF) * RTE_LPM_TBL8_GROUP_NUM_ENTRIES; + ptbl = (const uint32_t *)&lpm->tbl8[i8.u32[3]]; + tbl[3] = *ptbl; + } + + hop[0] = (tbl[0] & RTE_LPM_LOOKUP_SUCCESS) ? tbl[0] & 0x00FFFFFF : defv;lib/lpm/rte_lpm_scalar.h line 122
Quoted 10 lines
lib/lpm/rte_lpm_scalar.h new file +10
-0+ hop[1 ] = (tbl[1 ] &RTE_LPM_LOOKUP_SUCCESS ) ? tbl[1 ] &0x00FFFFFF : defv; + hop[2 ] = (tbl[2 ] &RTE_LPM_LOOKUP_SUCCESS ) ? tbl[2 ] &0x00FFFFFF : defv; + hop[3 ] = (tbl[3 ] &RTE_LPM_LOOKUP_SUCCESS ) ? tbl[3 ] &0x00FFFFFF : defv; +} + +#ifdef __cplusplus +} +#endif + +#endif /* _RTE_LPM_SCALAR_H_ */ --
Regards,
Vladimir
On Tue, May 24, 2022 at 6:28 PM Stanisław Kardach <[email protected]> wrote:
<snip>
Quoted 8 lines
That said I wonder why do we have different const requirements for
rte_lpm_lookup()andrte_lpm_lookupx4():
static inline int rte_lpm_lookup(structrte_lpm*lpm,uint32_tip,uint32_t*next_hop)
static inline void rte_lpm_lookupx4(const structrte_lpm*lpm,xmm_t
ip,uint32_thop[4],uint32_tdefv);
I think both should be const.
To re-iterate the question, should I also post a patch for changing rte_lpm_lookup() to add "const" to "struct rte_lpm *lpm" argument? rte_lpm_lookup_bulk_func() and rte_lpm_lookupx4() already take lpm as const.
I'm pushing because otherwise I get a const discard warning in the scalar version of rte_lpm_lookupx4() utilizing rte_lpm_lookup().
Best Regards,
Stanislaw Kardach
Hi Stanislaw,
Quoted 10 lines · Stanisław Kardach
On Tue, May 24, 2022 at 6:28 PM Stanisław Kardach <[email protected]> wrote:
<snip>Quoted 8 lines
That said I wonder why do we have different const requirements for
rte_lpm_lookup()andrte_lpm_lookupx4():
static inline int rte_lpm_lookup(structrte_lpm*lpm,uint32_tip,uint32_t*next_hop)
static inline void rte_lpm_lookupx4(const structrte_lpm*lpm,xmm_t
ip,uint32_thop[4],uint32_tdefv);
I think both should be const.
Quoted 6 lines
To re-iterate the question, should I also post a patch for changing
rte_lpm_lookup()to add "const" to "structrte_lpm*lpm" argument?rte_lpm_lookup_bulk_func()andrte_lpm_lookupx4()already take lpm as const.
I'm pushing because otherwise I get a const discard warning in the scalar version ofrte_lpm_lookupx4()utilizingrte_lpm_lookup().
Since these are inline functions, there will be no problems with the ABI/API, so please add const to the *lpm argument.
Thanks!
Quoted 3 lines
Best Regards,
Stanislaw Kardach
Signature · 2 lines
Regards, Vladimir
PATCH v2 1/2 lpm: add const to lpm arg of rte_lpm_lookup
In reply to Stanislaw KardachAll other rte_lpm_lookup* functions take lpm argument as a const. As the basic rte_lpm_lookup() performs the same function, it should also do that.
As this function is inline, no API/ABI change happens.
--- lib/lpm/rte_lpm.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
lib/lpm/rte_lpm.h +1 -1
@@ -279,7 +279,7 @@ rte_lpm_delete_all(struct rte_lpm *lpm);* -EINVAL for incorrect arguments, -ENOENT on lookup miss, 0 on lookup hit */ static inline int -rte_lpm_lookup (struct rte_lpm *lpm,uint32_t ip,uint32_t *next_hop) +rte_lpm_lookup (const struct rte_lpm *lpm,uint32_t ip,uint32_t *next_hop) {unsigned tbl24_index = (ip >>8 );uint32_t tbl_entry;
Signature · 1 line
2.30.2
PATCH v2 2/2 lpm: add a scalar version of lookupx4 function
From: Michal Mazurek <[email protected]>
Add an implementation of the rte_lpm_lookupx4() function for platforms without support for vector operations.
This will be useful in the upcoming RISC-V port as well as any platform which may want to start with a basic level of LPM support.
--- doc/guides/rel_notes/release_22_07.rst | 5 ++++ lib/lpm/meson.build | 1 + lib/lpm/rte_lpm.h | 4 ++- lib/lpm/rte_lpm_scalar.h | 36 ++++++++++++++++++++++++++ 4 files changed, 45 insertions(+), 1 deletion(-) create mode 100644 lib/lpm/rte_lpm_scalar.h
doc/guides/rel_notes/release_22_07.rst +5 -0
@@ -104,6 +104,11 @@ New Features * ``RTE_EVENT_QUEUE_ATTR_WEIGHT`` * ``RTE_EVENT_QUEUE_ATTR_AFFINITY`` +* **Added scalar version of the LPM library.** + + * Added scalar implementation of ``rte_lpm_lookupx4``. This is a fall-back + implementation for platforms that don't support vector operations. + Removed Items -------------
lib/lpm/meson.build +1 -0
@@ -14,6 +14,7 @@ headers = files('rte_lpm.h', 'rte_lpm6.h') indirect_headers += files( 'rte_lpm_altivec.h', 'rte_lpm_neon.h', + 'rte_lpm_scalar.h', 'rte_lpm_sse.h', 'rte_lpm_sve.h', )
lib/lpm/rte_lpm.h +3 -1
@@ -405,8 +405,10 @@ rte_lpm_lookupx4(const struct rte_lpm *lpm, xmm_t ip, uint32_t hop[4],#endif #elif defined(RTE_ARCH_PPC_64 )#include "rte_lpm_altivec.h" -#else +#elif defined(RTE_ARCH_X86 )#include "rte_lpm_sse.h" +#else +#include "rte_lpm_scalar.h" #endif #ifdef __cplusplus
lib/lpm/rte_lpm_scalar.h new file +36 -0
@@ -0,0 +1,36 @@ +/* SPDX-License-Identifier: BSD-3-Clause +* Copyright(c) 2022 StarFive +* Copyright(c) 2022 SiFive +* Copyright(c) 2022 Semihalf +*/ + +#ifndef _RTE_LPM_SCALAR_H_ +#define _RTE_LPM_SCALAR_H_ + +#include <rte_branch_prediction.h> +#include <rte_byteorder.h> +#include <rte_common.h> +#include <rte_vect.h> + +#ifdef __cplusplus +extern "C" { +#endif + +static inline void +rte_lpm_lookupx4 (const struct rte_lpm *lpm,xmm_t ip,uint32_t hop[4 ], +uint32_t defv) +{ +uint32_t nh; +int i, ret; + +for (i =0 ; i <4 ; i++) { + ret =rte_lpm_lookup (lpm, ((rte_xmm_t )ip).u32[i], &nh); + hop[i] = (ret ==0 ) ? nh : defv; + } +} + +#ifdef __cplusplus +} +#endif + +#endif /* _RTE_LPM_SCALAR_H_ */
Signature · 1 line
2.30.2
lib/lpm/rte_lpm_scalar.h line 30
Quoted 12 lines · On Fri, 27 May 2022 20:18:22 +0200 Stanislaw Kardach <[email protected]> wrote:
lib/lpm/rte_lpm_scalar.h new file +12
-0+static inline void +rte_lpm_lookupx4 (const struct rte_lpm *lpm,xmm_t ip,uint32_t hop[4 ], +uint32_t defv) +{ +uint32_t nh; +int i, ret; + +for (i =0 ; i <4 ; i++) { + ret =rte_lpm_lookup (lpm, ((rte_xmm_t )ip).u32[i], &nh); + hop[i] = (ret ==0 ) ? nh : defv; + } +}
For performance, manually unroll the loop.
Quoted 17 lines · Stephen Hemminger
lib/lpm/rte_lpm_scalar.h line 30
Quoted 12 lines · On Fri, 27 May 2022 20:18:22 +0200 Stanislaw Kardach <[email protected]> wrote:
lib/lpm/rte_lpm_scalar.h new file +12
-0+static inline void +rte_lpm_lookupx4 (const struct rte_lpm *lpm,xmm_t ip,uint32_t hop[4 ], +uint32_t defv) +{ +uint32_t nh; +int i, ret; + +for (i =0 ; i <4 ; i++) { + ret =rte_lpm_lookup (lpm, ((rte_xmm_t )ip).u32[i], &nh); + hop[i] = (ret ==0 ) ? nh : defv; + } +}For performance, manually unroll the loop.
Given a constant 4x iterations, will compilers not unroll this automatically. I think the loop is a little clearer if it can be kept
/Bruce
Quoted 23 lines
From: Bruce Richardson [mailto:[email protected]]
Sent: Monday, 30 May 2022 09.52Quoted 5 lines · Stephen Hemminger
Review
Quoted 2 lines · On Fri, 27 May 2022 20:18:22 +0200 Stanislaw Kardach <[email protected]> wrote:
(quoted diff) +2
-0+static inline void +rte_lpm_lookupx4(const struct rte_lpm *lpm, xmm_t ip, uint32_thop[4],
Quoted 4 lines
Quoted 4 lines
lib/lpm/rte_lpm_scalar.h new file +4
-0+ uint32_t defv) +{ +uint32_t nh; +int i, ret;Quoted 8 lines
lib/lpm/rte_lpm_scalar.h line 30
Quoted 6 lines
lib/lpm/rte_lpm_scalar.h new file +6
-0+ +for (i =0 ; i <4 ; i++) { + ret =rte_lpm_lookup (lpm, ((rte_xmm_t )ip).u32[i], &nh); + hop[i] = (ret ==0 ) ? nh : defv; + } +}For performance, manually unroll the loop.
Quoted 4 lines
Given a constant 4x iterations, will compilers not unroll this automatically. I think the loop is a little clearer if it can be kept
/Bruce
If in doubt, add this and look at the assembler output:
#define REVIEW_INLINE_FUNCTIONS 1
#if REVIEW_INLINE_FUNCTIONS /* For compiler output review purposes only. */ #pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wmissing-prototypes"
void review_rte_lpm_lookupx4(const struct rte_lpm *lpm, xmm_t ip, uint32_t hop[4], uint32_t defv)
{
rte_lpm_lookupx4(lpm, ip, hop, defv);
}#pragma GCC diagnostic pop
#endif /* REVIEW_INLINE_FUNCTIONS */
Quoted 36 lines · Morten Brørup
Quoted 23 lines
From: Bruce Richardson [mailto:[email protected]]
Sent: Monday, 30 May 2022 09.52Quoted 5 lines · Stephen Hemminger
Review
Quoted 2 lines · On Fri, 27 May 2022 20:18:22 +0200 Stanislaw Kardach <[email protected]> wrote:
(quoted diff) +2
-0+static inline void +rte_lpm_lookupx4(const struct rte_lpm *lpm, xmm_t ip, uint32_thop[4],
Quoted 4 lines
Quoted 4 lines
lib/lpm/rte_lpm_scalar.h new file +4
-0+ uint32_t defv) +{ +uint32_t nh; +int i, ret;Quoted 8 lines
lib/lpm/rte_lpm_scalar.h line 30
Quoted 6 lines
lib/lpm/rte_lpm_scalar.h new file +6
-0+ +for (i =0 ; i <4 ; i++) { + ret =rte_lpm_lookup (lpm, ((rte_xmm_t )ip).u32[i], &nh); + hop[i] = (ret ==0 ) ? nh : defv; + } +}For performance, manually unroll the loop.
Quoted 4 lines
Given a constant 4x iterations, will compilers not unroll this automatically. I think the loop is a little clearer if it can be kept
/Bruce
If in doubt, add this and look at the assembler output:
#define
REVIEW_INLINE_FUNCTIONS1#if
REVIEW_INLINE_FUNCTIONS/* For compiler output review purposes only. */ #pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wmissing-prototypes"
voidreview_rte_lpm_lookupx4(const struct rte_lpm *lpm, xmm_t ip, uint32_t hop[4], uint32_t defv)
Quoted 6 lines
{ rte_lpm_lookupx4(lpm, ip, hop, defv); }#pragma GCC diagnostic pop
#endif /*REVIEW_INLINE_FUNCTIONS*/
Used godbolt.org to check and indeed the function is not unrolled. (Gcc 11.2, with flags "-O3 -march=icelake-server").
Manually unrolling changes the assembly generated in interesting ways. For example, it appears to generate more cmov-type instructions for the miss/default-value case rather than using branches as in the looped version. Whether this is better or not may depend upon usecase - if one expects most lpm lookup entries to hit, then having (predictable) branches may well be cheaper.
In any case, I'll withdraw any object to unrolling, but I'm still not convinced it's necessary.
/Bruce
Quoted 55 lines · Bruce Richardson
Quoted 36 lines · Morten Brørup
Quoted 23 lines
From: Bruce Richardson [mailto:[email protected]]
Sent: Monday, 30 May 2022 09.52Quoted 5 lines · Stephen Hemminger
Review
Quoted 2 lines · On Fri, 27 May 2022 20:18:22 +0200 Stanislaw Kardach <[email protected]> wrote:
(quoted diff) +2
-0+static inline void +rte_lpm_lookupx4(const struct rte_lpm *lpm, xmm_t ip, uint32_thop[4],
Quoted 4 lines
Quoted 4 lines
lib/lpm/rte_lpm_scalar.h new file +4
-0+ uint32_t defv) +{ +uint32_t nh; +int i, ret;Quoted 8 lines
lib/lpm/rte_lpm_scalar.h line 30
Quoted 6 lines
lib/lpm/rte_lpm_scalar.h new file +6
-0+ +for (i =0 ; i <4 ; i++) { + ret =rte_lpm_lookup (lpm, ((rte_xmm_t )ip).u32[i], &nh); + hop[i] = (ret ==0 ) ? nh : defv; + } +}For performance, manually unroll the loop.
Quoted 4 lines
Given a constant 4x iterations, will compilers not unroll this automatically. I think the loop is a little clearer if it can be kept
/Bruce
If in doubt, add this and look at the assembler output:
#define
REVIEW_INLINE_FUNCTIONS1#if
REVIEW_INLINE_FUNCTIONS/* For compiler output review purposes only. */ #pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wmissing-prototypes"
voidreview_rte_lpm_lookupx4(const struct rte_lpm *lpm, xmm_t ip, uint32_t hop[4], uint32_t defv)Quoted 6 lines
{ rte_lpm_lookupx4(lpm, ip, hop, defv); }#pragma GCC diagnostic pop
#endif /*REVIEW_INLINE_FUNCTIONS*/Used godbolt.org to check and indeed the function is not unrolled. (Gcc 11.2, with flags "-O3 -march=icelake-server").
Manually unrolling changes the assembly generated in interesting ways. For example, it appears to generate more cmov-type instructions for the miss/default-value case rather than using branches as in the looped version. Whether this is better or not may depend upon usecase - if one expects most lpm lookup entries to hit, then having (predictable) branches may well be cheaper.
Quoted 4 lines
In any case, I'll withdraw any object to unrolling, but I'm still not convinced it's necessary.
/Bruce
Interestingly enough until I've defined unlikely() in godbolt, I did not get any automatic unrolling on godbolt (either with x86 or RISC-V GCC). Did you get any compilation warnings?
That said it only happens on O3 since it implies -fpeel-loops. O3 is the default for DPDK.
Quoted 57 lines · Stanisław Kardach
Quoted 55 lines · Bruce Richardson
Quoted 36 lines · Morten Brørup
Quoted 23 lines
From: Bruce Richardson [mailto:[email protected]]
Sent: Monday, 30 May 2022 09.52Quoted 5 lines · Stephen Hemminger
Review
Quoted 2 lines · On Fri, 27 May 2022 20:18:22 +0200 Stanislaw Kardach <[email protected]> wrote:
(quoted diff) +2
-0+static inline void +rte_lpm_lookupx4(const struct rte_lpm *lpm, xmm_t ip, uint32_thop[4],
Quoted 4 lines
Quoted 4 lines
lib/lpm/rte_lpm_scalar.h new file +4
-0+ uint32_t defv) +{ +uint32_t nh; +int i, ret;Quoted 8 lines
lib/lpm/rte_lpm_scalar.h line 30
Quoted 6 lines
lib/lpm/rte_lpm_scalar.h new file +6
-0+ +for (i =0 ; i <4 ; i++) { + ret =rte_lpm_lookup (lpm, ((rte_xmm_t )ip).u32[i], &nh); + hop[i] = (ret ==0 ) ? nh : defv; + } +}For performance, manually unroll the loop.
Quoted 4 lines
Given a constant 4x iterations, will compilers not unroll this automatically. I think the loop is a little clearer if it can be kept
/Bruce
If in doubt, add this and look at the assembler output:
#define
REVIEW_INLINE_FUNCTIONS1#if
REVIEW_INLINE_FUNCTIONS/* For compiler output review purposes only. */ #pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wmissing-prototypes"
voidreview_rte_lpm_lookupx4(const struct rte_lpm *lpm, xmm_t ip, uint32_t hop[4], uint32_t defv)Quoted 6 lines
{ rte_lpm_lookupx4(lpm, ip, hop, defv); }#pragma GCC diagnostic pop
#endif /*REVIEW_INLINE_FUNCTIONS*/Used godbolt.org to check and indeed the function is not unrolled. (Gcc 11.2, with flags "-O3 -march=icelake-server").
Manually unrolling changes the assembly generated in interesting ways. For example, it appears to generate more cmov-type instructions for the miss/default-value case rather than using branches as in the looped version. Whether this is better or not may depend upon usecase - if one expects most lpm lookup entries to hit, then having (predictable) branches may well be cheaper.
Quoted 7 lines
Quoted 4 lines
In any case, I'll withdraw any object to unrolling, but I'm still not convinced it's necessary.
/Bruce
Interestingly enough until I've defined
unlikely()in godbolt, I did not get any automatic unrolling on godbolt (either with x86 or RISC-V GCC). Did you get any compilation warnings?
That matches what I saw. I then just used manual unrolling i.e. copy-paste the 2 lines 4 times, to see what the output was like then.
Quoted 2 lines
That said it only happens on O3 since it implies -fpeel-loops. O3 is the default for DPDK.
PATCH v3 1/2 lpm: add const to lpm arg of rte_lpm_lookup
In reply to Stanislaw KardachAll other rte_lpm_lookup* functions take lpm argument as a const. As the basic rte_lpm_lookup() performs the same function, it should also do that.
As this function is inline, no API/ABI change happens.
--- lib/lpm/rte_lpm.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
lib/lpm/rte_lpm.h +1 -1
@@ -279,7 +279,7 @@ rte_lpm_delete_all(struct rte_lpm *lpm);* -EINVAL for incorrect arguments, -ENOENT on lookup miss, 0 on lookup hit */ static inline int -rte_lpm_lookup (struct rte_lpm *lpm,uint32_t ip,uint32_t *next_hop) +rte_lpm_lookup (const struct rte_lpm *lpm,uint32_t ip,uint32_t *next_hop) {unsigned tbl24_index = (ip >>8 );uint32_t tbl_entry;
Signature · 1 line
2.30.2
PATCH v3 2/2 lpm: add a scalar version of lookupx4 function
From: Michal Mazurek <[email protected]>
Add an implementation of the rte_lpm_lookupx4() function for platforms without support for vector operations.
This will be useful in the upcoming RISC-V port as well as any platform which may want to start with a basic level of LPM support.
--- doc/guides/rel_notes/release_22_07.rst | 5 ++++ lib/lpm/meson.build | 1 + lib/lpm/rte_lpm.h | 4 ++- lib/lpm/rte_lpm_scalar.h | 40 ++++++++++++++++++++++++++ 4 files changed, 49 insertions(+), 1 deletion(-) create mode 100644 lib/lpm/rte_lpm_scalar.h
doc/guides/rel_notes/release_22_07.rst +5 -0
@@ -104,6 +104,11 @@ New Features * ``RTE_EVENT_QUEUE_ATTR_WEIGHT`` * ``RTE_EVENT_QUEUE_ATTR_AFFINITY`` +* **Added scalar version of the LPM library.** + + * Added scalar implementation of ``rte_lpm_lookupx4``. This is a fall-back + implementation for platforms that don't support vector operations. + Removed Items -------------
lib/lpm/meson.build +1 -0
@@ -14,6 +14,7 @@ headers = files('rte_lpm.h', 'rte_lpm6.h') indirect_headers += files( 'rte_lpm_altivec.h', 'rte_lpm_neon.h', + 'rte_lpm_scalar.h', 'rte_lpm_sse.h', 'rte_lpm_sve.h', )
lib/lpm/rte_lpm.h +3 -1
@@ -405,8 +405,10 @@ rte_lpm_lookupx4(const struct rte_lpm *lpm, xmm_t ip, uint32_t hop[4],#endif #elif defined(RTE_ARCH_PPC_64 )#include "rte_lpm_altivec.h" -#else +#elif defined(RTE_ARCH_X86 )#include "rte_lpm_sse.h" +#else +#include "rte_lpm_scalar.h" #endif #ifdef __cplusplus
lib/lpm/rte_lpm_scalar.h new file +40 -0
@@ -0,0 +1,40 @@ +/* SPDX-License-Identifier: BSD-3-Clause +* Copyright(c) 2022 StarFive +* Copyright(c) 2022 SiFive +* Copyright(c) 2022 Semihalf +*/ + +#ifndef _RTE_LPM_SCALAR_H_ +#define _RTE_LPM_SCALAR_H_ + +#include <rte_branch_prediction.h> +#include <rte_byteorder.h> +#include <rte_common.h> +#include <rte_vect.h> + +#ifdef __cplusplus +extern "C" { +#endif + +static inline void +rte_lpm_lookupx4 (const struct rte_lpm *lpm,xmm_t ip,uint32_t hop[4 ], +uint32_t defv) +{ +uint32_t nh; +int ret; + + ret =rte_lpm_lookup (lpm, ((rte_xmm_t )ip).u32[0 ], &nh); + hop[0 ] = (ret ==0 ) ? nh : defv; + ret =rte_lpm_lookup (lpm, ((rte_xmm_t )ip).u32[1 ], &nh); + hop[1 ] = (ret ==0 ) ? nh : defv; + ret =rte_lpm_lookup (lpm, ((rte_xmm_t )ip).u32[2 ], &nh); + hop[2 ] = (ret ==0 ) ? nh : defv; + ret =rte_lpm_lookup (lpm, ((rte_xmm_t )ip).u32[3 ], &nh); + hop[3 ] = (ret ==0 ) ? nh : defv; +} + +#ifdef __cplusplus +} +#endif + +#endif /* _RTE_LPM_SCALAR_H_ */
Signature · 1 line
2.30.2
Hi Stanislaw,
Quoted 70 lines · Stanislaw Kardach
From: Michal Mazurek <[email protected]>
Add an implementation of the
rte_lpm_lookupx4()function for platforms without support for vector operations.This will be useful in the upcoming RISC-V port as well as any platform which may want to start with a basic level of LPM support.
Signed-off-by Michal Mazurek <[email protected]>Signed-off-by Stanislaw Kardach <[email protected]>--- doc/guides/rel_notes/release_22_07.rst | 5 ++++ lib/lpm/meson.build | 1 + lib/lpm/rte_lpm.h | 4 ++- lib/lpm/rte_lpm_scalar.h | 40 ++++++++++++++++++++++++++ 4 files changed, 49 insertions(+), 1 deletion(-)create mode 100644
lib/lpm/rte_lpm_scalar.hdoc/guides/rel_notes/release_22_07.rst +5
-0@@ -104,6 +104,11 @@ New Features * ``RTE_EVENT_QUEUE_ATTR_WEIGHT`` * ``RTE_EVENT_QUEUE_ATTR_AFFINITY`` +* **Added scalar version of the LPM library.** + + * Added scalar implementation of ``rte_lpm_lookupx4``. This is a fall-back + implementation for platforms that don't support vector operations. + Removed Items -------------lib/lpm/meson.build +1
-0@@ -14,6 +14,7 @@ headers = files('rte_lpm.h', 'rte_lpm6.h') indirect_headers += files( 'rte_lpm_altivec.h', 'rte_lpm_neon.h', + 'rte_lpm_scalar.h', 'rte_lpm_sse.h', 'rte_lpm_sve.h', )lib/lpm/rte_lpm.h +3
-1@@ -405,8 +405,10 @@ rte_lpm_lookupx4(const struct rte_lpm *lpm, xmm_t ip, uint32_t hop[4],#endif #elif defined(RTE_ARCH_PPC_64 )#include "rte_lpm_altivec.h" -#else +#elif defined(RTE_ARCH_X86 )#include "rte_lpm_sse.h" +#else +#include "rte_lpm_scalar.h" #endif #ifdef __cpluspluslib/lpm/rte_lpm_scalar.h new file +2
-0@@ -0,0 +1,40 @@ +/* SPDX-License-Identifier: BSD-3-Clause +* Copyright(c) 2022 StarFive
lib/lpm/rte_lpm_scalar.h line 12
Quoted 10 lines
lib/lpm/rte_lpm_scalar.h new file +10
-0+* Copyright(c) 2022 SiFive +* Copyright(c) 2022 Semihalf +*/ + +#ifndef _RTE_LPM_SCALAR_H_ +#define _RTE_LPM_SCALAR_H_ + +#include <rte_branch_prediction.h> +#include <rte_byteorder.h> +#include <rte_common.h>
Just a one nit, I think these 3 headers are not needed and can be removed. Apart from it looks good to me. Thanks!
Quoted 18 lines
lib/lpm/rte_lpm_scalar.h new file +18
-0+#include <rte_vect.h> + +#ifdef __cplusplus +extern "C" { +#endif + +static inline void +rte_lpm_lookupx4 (const struct rte_lpm *lpm,xmm_t ip,uint32_t hop[4 ], +uint32_t defv) +{ +uint32_t nh; +int ret; + + ret =rte_lpm_lookup (lpm, ((rte_xmm_t )ip).u32[0 ], &nh); + hop[0 ] = (ret ==0 ) ? nh : defv; + ret =rte_lpm_lookup (lpm, ((rte_xmm_t )ip).u32[1 ], &nh); + hop[1 ] = (ret ==0 ) ? nh : defv; + ret =rte_lpm_lookup (lpm, ((rte_xmm_t )ip).u32[2 ], &nh);
lib/lpm/rte_lpm_scalar.h line 40
Quoted 10 lines
lib/lpm/rte_lpm_scalar.h new file +10
-0+ hop[2 ] = (ret ==0 ) ? nh : defv; + ret =rte_lpm_lookup (lpm, ((rte_xmm_t )ip).u32[3 ], &nh); + hop[3 ] = (ret ==0 ) ? nh : defv; +} + +#ifdef __cplusplus +} +#endif + +#endif /* _RTE_LPM_SCALAR_H_ */
Signature · 2 lines
Regards, Vladimir
Hi Vladimir,
Quoted 81 lines · Vladimir
Hi Stanislaw,
Quoted 76 lines · Stanislaw Kardach
From: Michal Mazurek <[email protected]>
Add an implementation of the
rte_lpm_lookupx4()function for platforms without support for vector operations.This will be useful in the upcoming RISC-V port as well as any platform which may want to start with a basic level of LPM support.
Signed-off-by Michal Mazurek <[email protected]>Signed-off-by Stanislaw Kardach <[email protected]>--- doc/guides/rel_notes/release_22_07.rst | 5 ++++ lib/lpm/meson.build | 1 + lib/lpm/rte_lpm.h | 4 ++- lib/lpm/rte_lpm_scalar.h | 40 ++++++++++++++++++++++++++ 4 files changed, 49 insertions(+), 1 deletion(-)create mode 100644
lib/lpm/rte_lpm_scalar.hdoc/guides/rel_notes/release_22_07.rst +5
-0@@ -104,6 +104,11 @@ New Features * ``RTE_EVENT_QUEUE_ATTR_WEIGHT`` * ``RTE_EVENT_QUEUE_ATTR_AFFINITY`` +* **Added scalar version of the LPM library.** + + * Added scalar implementation of ``rte_lpm_lookupx4``. This is a fall-back + implementation for platforms that don't support vector operations. + Removed Items -------------lib/lpm/meson.build +1
-0@@ -14,6 +14,7 @@ headers = files('rte_lpm.h', 'rte_lpm6.h') indirect_headers += files( 'rte_lpm_altivec.h', 'rte_lpm_neon.h', + 'rte_lpm_scalar.h', 'rte_lpm_sse.h', 'rte_lpm_sve.h', )lib/lpm/rte_lpm.h +3
-1@@ -405,8 +405,10 @@ rte_lpm_lookupx4(const struct rte_lpm *lpm, xmm_t ip, uint32_t hop[4],#endif #elif defined(RTE_ARCH_PPC_64 )#include "rte_lpm_altivec.h" -#else +#elif defined(RTE_ARCH_X86 )#include "rte_lpm_sse.h" +#else +#include "rte_lpm_scalar.h" #endif #ifdef __cpluspluslib/lpm/rte_lpm_scalar.h new file +8
-0@@ -0,0 +1,40 @@ +/* SPDX-License-Identifier: BSD-3-Clause +* Copyright(c) 2022 StarFive +* Copyright(c) 2022 SiFive +* Copyright(c) 2022 Semihalf +*/ + +#ifndef _RTE_LPM_SCALAR_H_ +#define _RTE_LPM_SCALAR_H_
Quoted 8 lines
lib/lpm/rte_lpm_scalar.h line 12
Quoted 4 lines
lib/lpm/rte_lpm_scalar.h new file +4
-0+ +#include <rte_branch_prediction.h> +#include <rte_byteorder.h> +#include <rte_common.h> Just a one nit, I think these 3 headers are not needed and can be removed. Apart from it looks good to me.
Thanks!
Thanks for catching this. I'll send a followup right away.
Quoted 35 lines
Quoted 19 lines
lib/lpm/rte_lpm_scalar.h new file +18
-0+#include <rte_vect.h> + +#ifdef __cplusplus +extern "C" { +#endif + +static inline void +rte_lpm_lookupx4 (const struct rte_lpm *lpm,xmm_t ip,uint32_t hop[4 ], +uint32_t defv) +{ +uint32_t nh; +int ret; + + ret =rte_lpm_lookup (lpm, ((rte_xmm_t )ip).u32[0 ], &nh); + hop[0 ] = (ret ==0 ) ? nh : defv; + ret =rte_lpm_lookup (lpm, ((rte_xmm_t )ip).u32[1 ], &nh); + hop[1 ] = (ret ==0 ) ? nh : defv; + ret =rte_lpm_lookup (lpm, ((rte_xmm_t )ip).u32[2 ], &nh);lib/lpm/rte_lpm_scalar.h line 40
Quoted 10 lines
lib/lpm/rte_lpm_scalar.h new file +10
-0+ hop[2 ] = (ret ==0 ) ? nh : defv; + ret =rte_lpm_lookup (lpm, ((rte_xmm_t )ip).u32[3 ], &nh); + hop[3 ] = (ret ==0 ) ? nh : defv; +} + +#ifdef __cplusplus +} +#endif + +#endif /* _RTE_LPM_SCALAR_H_ */ --
Regards,
Vladimir
Re: [PATCH v3 1/2] lpm: add const to lpm arg of rte_lpm_lookup
In reply to Stanislaw KardachQuoted 7 lines · On Mon, 30 May 2022 20:24:36 +0200 Stanislaw Kardach <[email protected]> wrote:
All other rte_lpm_lookup* functions take lpm argument as a const. As the basic
rte_lpm_lookup()performs the same function, it should also do that.As this function is inline, no API/ABI change happens.
Signed-off-by Stanislaw Kardach <[email protected]>
Re: [PATCH v3 1/2] lpm: add const to lpm arg of rte_lpm_lookup
In reply to Stanislaw KardachQuoted 16 lines · Stanislaw Kardach
All other rte_lpm_lookup* functions take lpm argument as a const. As the basic
rte_lpm_lookup()performs the same function, it should also do that.As this function is inline, no API/ABI change happens.
Signed-off-by Stanislaw Kardach <[email protected]>--- lib/lpm/rte_lpm.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)lib/lpm/rte_lpm.h +0
-0
lib/lpm/rte_lpm.h rte_lpm_delete_all(struct rte_lpm *lpm); · line 285
Quoted 8 lines
lib/lpm/rte_lpm.h +1
-1@@ -279,7 +279,7 @@ rte_lpm_delete_all(struct rte_lpm *lpm);* -EINVAL for incorrect arguments, -ENOENT on lookup miss, 0 on lookup hit */ static inline int -rte_lpm_lookup (struct rte_lpm *lpm,uint32_t ip,uint32_t *next_hop) +rte_lpm_lookup (const struct rte_lpm *lpm,uint32_t ip,uint32_t *next_hop) {unsigned tbl24_index = (ip >>8 );uint32_t tbl_entry;
Signature · 2 lines
Regards, Vladimir