diff mbox series

[v3,1/8] net/hns3: support runtime config to select IO burst func

Message ID 1615549872-49720-2-git-send-email-humin29@huawei.com (mailing list archive)
State Superseded, archived
Delegated to: Ferruh Yigit
Headers show
Series features and bugfixes for hns3 | expand

Checks

Context Check Description
ci/checkpatch success coding style OK

Commit Message

Min Hu (Connor) March 12, 2021, 11:51 a.m. UTC
From: Chengwen Feng <fengchengwen@huawei.com>

Currently, the driver support multiple IO burst function and auto
selection of the most appropriate function based on offload
configuration.

Most applications such as l2fwd/l3fwd don't provide the means to
change offload configuration, so it will use the auto selection's io
burst function.

This patch support runtime config to select io burst function, which
add two config: rx_func_hint and tx_func_hint, both could assign
vec/sve/simple/common.

The driver will use the following rules to select io burst func:
a. if hint equal vec and meet the vec Rx/Tx usage condition then use
the neon function.
b. if hint equal sve and meet the sve Rx/Tx usage condition then use
the sve function.
c. if hint equal simple and meet the simple Rx/Tx usage condition then
use the simple function.
d. if hint equal common then use the common function.
e. if hint not set then:
e.1. if meet the vec Rx/Tx usage condition then use the neon function.
e.2. if meet the simple Rx/Tx usage condition then use the simple
function.
e.3. else use the common function.

Note: the sve Rx/Tx usage condition based on the vec Rx/Tx usage
condition and runtime environment (which must support SVE).

In the previous versions, driver will preferred use the sve function
when meet the sve Rx/Tx usage condition, but in this case driver could
get better performance if use the neon function.

Signed-off-by: Chengwen Feng <fengchengwen@huawei.com>
Signed-off-by: Min Hu (Connor) <humin29@huawei.com>
---
 doc/guides/nics/hns3.rst               | 20 +++++++++
 doc/guides/rel_notes/release_21_05.rst |  1 +
 drivers/net/hns3/hns3_ethdev.c         | 77 ++++++++++++++++++++++++++++++++++
 drivers/net/hns3/hns3_ethdev.h         | 15 +++++++
 drivers/net/hns3/hns3_ethdev_vf.c      |  4 ++
 drivers/net/hns3/hns3_rxtx.c           | 54 +++++++++++++++++-------
 6 files changed, 157 insertions(+), 14 deletions(-)

Comments

Ferruh Yigit March 16, 2021, 12:40 p.m. UTC | #1
On 3/12/2021 11:51 AM, Min Hu (Connor) wrote:
> From: Chengwen Feng <fengchengwen@huawei.com>
> 
> Currently, the driver support multiple IO burst function and auto
> selection of the most appropriate function based on offload
> configuration.
> 
> Most applications such as l2fwd/l3fwd don't provide the means to
> change offload configuration, so it will use the auto selection's io
> burst function.
> 
> This patch support runtime config to select io burst function, which
> add two config: rx_func_hint and tx_func_hint, both could assign
> vec/sve/simple/common.
> 
> The driver will use the following rules to select io burst func:
> a. if hint equal vec and meet the vec Rx/Tx usage condition then use
> the neon function.
> b. if hint equal sve and meet the sve Rx/Tx usage condition then use
> the sve function.
> c. if hint equal simple and meet the simple Rx/Tx usage condition then
> use the simple function.
> d. if hint equal common then use the common function.
> e. if hint not set then:
> e.1. if meet the vec Rx/Tx usage condition then use the neon function.
> e.2. if meet the simple Rx/Tx usage condition then use the simple
> function.
> e.3. else use the common function.
> 
> Note: the sve Rx/Tx usage condition based on the vec Rx/Tx usage
> condition and runtime environment (which must support SVE).
> 
> In the previous versions, driver will preferred use the sve function
> when meet the sve Rx/Tx usage condition, but in this case driver could
> get better performance if use the neon function.
> 
> Signed-off-by: Chengwen Feng <fengchengwen@huawei.com>
> Signed-off-by: Min Hu (Connor) <humin29@huawei.com>
> ---
>   doc/guides/nics/hns3.rst               | 20 +++++++++
>   doc/guides/rel_notes/release_21_05.rst |  1 +
>   drivers/net/hns3/hns3_ethdev.c         | 77 ++++++++++++++++++++++++++++++++++
>   drivers/net/hns3/hns3_ethdev.h         | 15 +++++++
>   drivers/net/hns3/hns3_ethdev_vf.c      |  4 ++
>   drivers/net/hns3/hns3_rxtx.c           | 54 +++++++++++++++++-------
>   6 files changed, 157 insertions(+), 14 deletions(-)
> 
> diff --git a/doc/guides/nics/hns3.rst b/doc/guides/nics/hns3.rst
> index 84bd7a3..40d2e3b 100644
> --- a/doc/guides/nics/hns3.rst
> +++ b/doc/guides/nics/hns3.rst
> @@ -46,6 +46,26 @@ Prerequisites
>   - Follow the DPDK :ref:`Getting Started Guide for Linux <linux_gsg>` to setup the basic DPDK environment.
>   
>   
> +Runtime Config Options
> +----------------------
> +
> +- ``rx_func_hint`` (default ``none``)
> +
> +  Used to select Rx burst function, supported value are "vec", "sve", "simple", "common".
> +  When equal "vec" and meet the vector Rx usage condition then use the neon Rx function.
> +  When equal "sve" and meet the sve Rx usage condition then use the sve Rx function.
> +  When equal "simple" and meet the simple Rx usage condition then use the simple Rx function.
> +  When equal "common" then use the common Rx function.
> +
> +- ``tx_func_hint`` (default ``none``)
> +
> +  Used to select Tx burst function, supported value are "vec", "sve", "simple", "common".
> +  When equal "vec" and meet the vector Tx usage condition then use the neon Tx function.
> +  When equal "sve" and meet the sve Tx usage condition then use the sve Tx function.
> +  When equal "simple" and meet the simple Tx usage condition then use the simple Tx function.
> +  When equal "common" then use the common Tx function.
> +

I think 'vec' & 'sve' are more self explenatory, but can you please describe 
what is 'common' and 'simple', and the difference of these two?

btw, since both 'neon' and 'sve' are vector implementations, what do you think 
to have arguments as 'neon' & 'sve', instead of 'vec' & 'sve'?
Min Hu (Connor) March 17, 2021, 1:14 a.m. UTC | #2
在 2021/3/16 20:40, Ferruh Yigit 写道:
> On 3/12/2021 11:51 AM, Min Hu (Connor) wrote:
>> From: Chengwen Feng <fengchengwen@huawei.com>
>>
>> Currently, the driver support multiple IO burst function and auto
>> selection of the most appropriate function based on offload
>> configuration.
>>
>> Most applications such as l2fwd/l3fwd don't provide the means to
>> change offload configuration, so it will use the auto selection's io
>> burst function.
>>
>> This patch support runtime config to select io burst function, which
>> add two config: rx_func_hint and tx_func_hint, both could assign
>> vec/sve/simple/common.
>>
>> The driver will use the following rules to select io burst func:
>> a. if hint equal vec and meet the vec Rx/Tx usage condition then use
>> the neon function.
>> b. if hint equal sve and meet the sve Rx/Tx usage condition then use
>> the sve function.
>> c. if hint equal simple and meet the simple Rx/Tx usage condition then
>> use the simple function.
>> d. if hint equal common then use the common function.
>> e. if hint not set then:
>> e.1. if meet the vec Rx/Tx usage condition then use the neon function.
>> e.2. if meet the simple Rx/Tx usage condition then use the simple
>> function.
>> e.3. else use the common function.
>>
>> Note: the sve Rx/Tx usage condition based on the vec Rx/Tx usage
>> condition and runtime environment (which must support SVE).
>>
>> In the previous versions, driver will preferred use the sve function
>> when meet the sve Rx/Tx usage condition, but in this case driver could
>> get better performance if use the neon function.
>>
>> Signed-off-by: Chengwen Feng <fengchengwen@huawei.com>
>> Signed-off-by: Min Hu (Connor) <humin29@huawei.com>
>> ---
>>   doc/guides/nics/hns3.rst               | 20 +++++++++
>>   doc/guides/rel_notes/release_21_05.rst |  1 +
>>   drivers/net/hns3/hns3_ethdev.c         | 77 
>> ++++++++++++++++++++++++++++++++++
>>   drivers/net/hns3/hns3_ethdev.h         | 15 +++++++
>>   drivers/net/hns3/hns3_ethdev_vf.c      |  4 ++
>>   drivers/net/hns3/hns3_rxtx.c           | 54 +++++++++++++++++-------
>>   6 files changed, 157 insertions(+), 14 deletions(-)
>>
>> diff --git a/doc/guides/nics/hns3.rst b/doc/guides/nics/hns3.rst
>> index 84bd7a3..40d2e3b 100644
>> --- a/doc/guides/nics/hns3.rst
>> +++ b/doc/guides/nics/hns3.rst
>> @@ -46,6 +46,26 @@ Prerequisites
>>   - Follow the DPDK :ref:`Getting Started Guide for Linux <linux_gsg>` 
>> to setup the basic DPDK environment.
>> +Runtime Config Options
>> +----------------------
>> +
>> +- ``rx_func_hint`` (default ``none``)
>> +
>> +  Used to select Rx burst function, supported value are "vec", "sve", 
>> "simple", "common".
>> +  When equal "vec" and meet the vector Rx usage condition then use 
>> the neon Rx function.
>> +  When equal "sve" and meet the sve Rx usage condition then use the 
>> sve Rx function.
>> +  When equal "simple" and meet the simple Rx usage condition then use 
>> the simple Rx function.
>> +  When equal "common" then use the common Rx function.
>> +
>> +- ``tx_func_hint`` (default ``none``)
>> +
>> +  Used to select Tx burst function, supported value are "vec", "sve", 
>> "simple", "common".
>> +  When equal "vec" and meet the vector Tx usage condition then use 
>> the neon Tx function.
>> +  When equal "sve" and meet the sve Tx usage condition then use the 
>> sve Tx function.
>> +  When equal "simple" and meet the simple Tx usage condition then use 
>> the simple Tx function.
>> +  When equal "common" then use the common Tx function.
>> +
> 
> I think 'vec' & 'sve' are more self explenatory, but can you please 
> describe what is 'common' and 'simple', and the difference of these two?
In the Rx direction, simple indicates that the Scalar algorithm obtained 
from rte_eth_rx_burst_mode_get, and common indicates that the Scalar 
Scattered algorithm obtained from rte_eth_rx_burst_mode_get.

In the TX direction, simple indicates that the Scalar Simple algorithm 
in the rte_eth_tx_burst_mode_get, and common indicates that the Scalar 
algorithm obtained in the rte_eth_tx_burst_mode_get.

Later, we will send a patch to modify the names obtained in 
rte_eth_rx_burst_mode_get, that is, the original Scalar is renamed 
Scalar Simple and Scalar Scattered is renamed Scalar. The Rx and Tx are 
not in correspondence, which may leads to misunderstanding.

> 
> btw, since both 'neon' and 'sve' are vector implementations, what do you 
> think to have arguments as 'neon' & 'sve', instead of 'vec' & 'sve'?
'vec' here means the default vector type in the current platform(In 
future, we will support NIC in different kinds of platform). when the 
DPDK run on different platform, the default vector will be different. 
For instance, now in ARM soc, 'vec' means 'neon', in X86 platform, 'vec'
means 'SSE/AVX' or others.

thanks



> .
Ferruh Yigit March 17, 2021, 3:28 p.m. UTC | #3
On 3/17/2021 1:14 AM, Min Hu (Connor) wrote:
> 
> 
> 在 2021/3/16 20:40, Ferruh Yigit 写道:
>> On 3/12/2021 11:51 AM, Min Hu (Connor) wrote:
>>> From: Chengwen Feng <fengchengwen@huawei.com>
>>>
>>> Currently, the driver support multiple IO burst function and auto
>>> selection of the most appropriate function based on offload
>>> configuration.
>>>
>>> Most applications such as l2fwd/l3fwd don't provide the means to
>>> change offload configuration, so it will use the auto selection's io
>>> burst function.
>>>
>>> This patch support runtime config to select io burst function, which
>>> add two config: rx_func_hint and tx_func_hint, both could assign
>>> vec/sve/simple/common.
>>>
>>> The driver will use the following rules to select io burst func:
>>> a. if hint equal vec and meet the vec Rx/Tx usage condition then use
>>> the neon function.
>>> b. if hint equal sve and meet the sve Rx/Tx usage condition then use
>>> the sve function.
>>> c. if hint equal simple and meet the simple Rx/Tx usage condition then
>>> use the simple function.
>>> d. if hint equal common then use the common function.
>>> e. if hint not set then:
>>> e.1. if meet the vec Rx/Tx usage condition then use the neon function.
>>> e.2. if meet the simple Rx/Tx usage condition then use the simple
>>> function.
>>> e.3. else use the common function.
>>>
>>> Note: the sve Rx/Tx usage condition based on the vec Rx/Tx usage
>>> condition and runtime environment (which must support SVE).
>>>
>>> In the previous versions, driver will preferred use the sve function
>>> when meet the sve Rx/Tx usage condition, but in this case driver could
>>> get better performance if use the neon function.
>>>
>>> Signed-off-by: Chengwen Feng <fengchengwen@huawei.com>
>>> Signed-off-by: Min Hu (Connor) <humin29@huawei.com>
>>> ---
>>>   doc/guides/nics/hns3.rst               | 20 +++++++++
>>>   doc/guides/rel_notes/release_21_05.rst |  1 +
>>>   drivers/net/hns3/hns3_ethdev.c         | 77 ++++++++++++++++++++++++++++++++++
>>>   drivers/net/hns3/hns3_ethdev.h         | 15 +++++++
>>>   drivers/net/hns3/hns3_ethdev_vf.c      |  4 ++
>>>   drivers/net/hns3/hns3_rxtx.c           | 54 +++++++++++++++++-------
>>>   6 files changed, 157 insertions(+), 14 deletions(-)
>>>
>>> diff --git a/doc/guides/nics/hns3.rst b/doc/guides/nics/hns3.rst
>>> index 84bd7a3..40d2e3b 100644
>>> --- a/doc/guides/nics/hns3.rst
>>> +++ b/doc/guides/nics/hns3.rst
>>> @@ -46,6 +46,26 @@ Prerequisites
>>>   - Follow the DPDK :ref:`Getting Started Guide for Linux <linux_gsg>` to 
>>> setup the basic DPDK environment.
>>> +Runtime Config Options
>>> +----------------------
>>> +
>>> +- ``rx_func_hint`` (default ``none``)
>>> +
>>> +  Used to select Rx burst function, supported value are "vec", "sve", 
>>> "simple", "common".
>>> +  When equal "vec" and meet the vector Rx usage condition then use the neon 
>>> Rx function.
>>> +  When equal "sve" and meet the sve Rx usage condition then use the sve Rx 
>>> function.
>>> +  When equal "simple" and meet the simple Rx usage condition then use the 
>>> simple Rx function.
>>> +  When equal "common" then use the common Rx function.
>>> +
>>> +- ``tx_func_hint`` (default ``none``)
>>> +
>>> +  Used to select Tx burst function, supported value are "vec", "sve", 
>>> "simple", "common".
>>> +  When equal "vec" and meet the vector Tx usage condition then use the neon 
>>> Tx function.
>>> +  When equal "sve" and meet the sve Tx usage condition then use the sve Tx 
>>> function.
>>> +  When equal "simple" and meet the simple Tx usage condition then use the 
>>> simple Tx function.
>>> +  When equal "common" then use the common Tx function.
>>> +
>>
>> I think 'vec' & 'sve' are more self explenatory, but can you please describe 
>> what is 'common' and 'simple', and the difference of these two?
> In the Rx direction, simple indicates that the Scalar algorithm obtained from 
> rte_eth_rx_burst_mode_get, and common indicates that the Scalar Scattered 
> algorithm obtained from rte_eth_rx_burst_mode_get.
> 
> In the TX direction, simple indicates that the Scalar Simple algorithm in the 
> rte_eth_tx_burst_mode_get, and common indicates that the Scalar algorithm 
> obtained in the rte_eth_tx_burst_mode_get.
> 

Got it, can you please document what you described above in this document?

> Later, we will send a patch to modify the names obtained in 
> rte_eth_rx_burst_mode_get, that is, the original Scalar is renamed Scalar Simple 
> and Scalar Scattered is renamed Scalar. The Rx and Tx are not in correspondence, 
> which may leads to misunderstanding.
> 
>>
>> btw, since both 'neon' and 'sve' are vector implementations, what do you think 
>> to have arguments as 'neon' & 'sve', instead of 'vec' & 'sve'?
> 'vec' here means the default vector type in the current platform(In future, we 
> will support NIC in different kinds of platform). when the DPDK run on different 
> platform, the default vector will be different. For instance, now in ARM soc, 
> 'vec' means 'neon', in X86 platform, 'vec'
> means 'SSE/AVX' or others.
> 

I see, again can you document this above, in document for 'vec' it says "use the 
neon", instead it can say something like "use default vector implementation, 
'neon' for Arm" ...

Btw, I can see v4 sent, but there is no changelog, and documentation seems same, 
what has changed there?
Min Hu (Connor) March 19, 2021, 1:08 a.m. UTC | #4
在 2021/3/17 23:28, Ferruh Yigit 写道:
> On 3/17/2021 1:14 AM, Min Hu (Connor) wrote:
>>
>>
>> 在 2021/3/16 20:40, Ferruh Yigit 写道:
>>> On 3/12/2021 11:51 AM, Min Hu (Connor) wrote:
>>>> From: Chengwen Feng <fengchengwen@huawei.com>
>>>>
>>>> Currently, the driver support multiple IO burst function and auto
>>>> selection of the most appropriate function based on offload
>>>> configuration.
>>>>
>>>> Most applications such as l2fwd/l3fwd don't provide the means to
>>>> change offload configuration, so it will use the auto selection's io
>>>> burst function.
>>>>
>>>> This patch support runtime config to select io burst function, which
>>>> add two config: rx_func_hint and tx_func_hint, both could assign
>>>> vec/sve/simple/common.
>>>>
>>>> The driver will use the following rules to select io burst func:
>>>> a. if hint equal vec and meet the vec Rx/Tx usage condition then use
>>>> the neon function.
>>>> b. if hint equal sve and meet the sve Rx/Tx usage condition then use
>>>> the sve function.
>>>> c. if hint equal simple and meet the simple Rx/Tx usage condition then
>>>> use the simple function.
>>>> d. if hint equal common then use the common function.
>>>> e. if hint not set then:
>>>> e.1. if meet the vec Rx/Tx usage condition then use the neon function.
>>>> e.2. if meet the simple Rx/Tx usage condition then use the simple
>>>> function.
>>>> e.3. else use the common function.
>>>>
>>>> Note: the sve Rx/Tx usage condition based on the vec Rx/Tx usage
>>>> condition and runtime environment (which must support SVE).
>>>>
>>>> In the previous versions, driver will preferred use the sve function
>>>> when meet the sve Rx/Tx usage condition, but in this case driver could
>>>> get better performance if use the neon function.
>>>>
>>>> Signed-off-by: Chengwen Feng <fengchengwen@huawei.com>
>>>> Signed-off-by: Min Hu (Connor) <humin29@huawei.com>
>>>> ---
>>>>   doc/guides/nics/hns3.rst               | 20 +++++++++
>>>>   doc/guides/rel_notes/release_21_05.rst |  1 +
>>>>   drivers/net/hns3/hns3_ethdev.c         | 77 
>>>> ++++++++++++++++++++++++++++++++++
>>>>   drivers/net/hns3/hns3_ethdev.h         | 15 +++++++
>>>>   drivers/net/hns3/hns3_ethdev_vf.c      |  4 ++
>>>>   drivers/net/hns3/hns3_rxtx.c           | 54 +++++++++++++++++-------
>>>>   6 files changed, 157 insertions(+), 14 deletions(-)
>>>>
>>>> diff --git a/doc/guides/nics/hns3.rst b/doc/guides/nics/hns3.rst
>>>> index 84bd7a3..40d2e3b 100644
>>>> --- a/doc/guides/nics/hns3.rst
>>>> +++ b/doc/guides/nics/hns3.rst
>>>> @@ -46,6 +46,26 @@ Prerequisites
>>>>   - Follow the DPDK :ref:`Getting Started Guide for Linux 
>>>> <linux_gsg>` to setup the basic DPDK environment.
>>>> +Runtime Config Options
>>>> +----------------------
>>>> +
>>>> +- ``rx_func_hint`` (default ``none``)
>>>> +
>>>> +  Used to select Rx burst function, supported value are "vec", 
>>>> "sve", "simple", "common".
>>>> +  When equal "vec" and meet the vector Rx usage condition then use 
>>>> the neon Rx function.
>>>> +  When equal "sve" and meet the sve Rx usage condition then use the 
>>>> sve Rx function.
>>>> +  When equal "simple" and meet the simple Rx usage condition then 
>>>> use the simple Rx function.
>>>> +  When equal "common" then use the common Rx function.
>>>> +
>>>> +- ``tx_func_hint`` (default ``none``)
>>>> +
>>>> +  Used to select Tx burst function, supported value are "vec", 
>>>> "sve", "simple", "common".
>>>> +  When equal "vec" and meet the vector Tx usage condition then use 
>>>> the neon Tx function.
>>>> +  When equal "sve" and meet the sve Tx usage condition then use the 
>>>> sve Tx function.
>>>> +  When equal "simple" and meet the simple Tx usage condition then 
>>>> use the simple Tx function.
>>>> +  When equal "common" then use the common Tx function.
>>>> +
>>>
>>> I think 'vec' & 'sve' are more self explenatory, but can you please 
>>> describe what is 'common' and 'simple', and the difference of these two?
>> In the Rx direction, simple indicates that the Scalar algorithm 
>> obtained from rte_eth_rx_burst_mode_get, and common indicates that the 
>> Scalar Scattered algorithm obtained from rte_eth_rx_burst_mode_get.
>>
>> In the TX direction, simple indicates that the Scalar Simple algorithm 
>> in the rte_eth_tx_burst_mode_get, and common indicates that the Scalar 
>> algorithm obtained in the rte_eth_tx_burst_mode_get.
>>
> 
> Got it, can you please document what you described above in this document?
> 
done it, I have sent V5, please check it, thanks.
>> Later, we will send a patch to modify the names obtained in 
>> rte_eth_rx_burst_mode_get, that is, the original Scalar is renamed 
>> Scalar Simple and Scalar Scattered is renamed Scalar. The Rx and Tx 
>> are not in correspondence, which may leads to misunderstanding.
>>
>>>
>>> btw, since both 'neon' and 'sve' are vector implementations, what do 
>>> you think to have arguments as 'neon' & 'sve', instead of 'vec' & 'sve'?
>> 'vec' here means the default vector type in the current platform(In 
>> future, we will support NIC in different kinds of platform). when the 
>> DPDK run on different platform, the default vector will be different. 
>> For instance, now in ARM soc, 'vec' means 'neon', in X86 platform, 'vec'
>> means 'SSE/AVX' or others.
>>
> 
> I see, again can you document this above, in document for 'vec' it says 
> "use the neon", instead it can say something like "use default vector 
> implementation, 'neon' for Arm" ...
> 
done it, I have sent V5, please check it, thanks.
> Btw, I can see v4 sent, but there is no changelog, and documentation 
> seems same, what has changed there?
> 
I have added changelog, I have sent V5, please check it, thanks.
> .
diff mbox series

Patch

diff --git a/doc/guides/nics/hns3.rst b/doc/guides/nics/hns3.rst
index 84bd7a3..40d2e3b 100644
--- a/doc/guides/nics/hns3.rst
+++ b/doc/guides/nics/hns3.rst
@@ -46,6 +46,26 @@  Prerequisites
 - Follow the DPDK :ref:`Getting Started Guide for Linux <linux_gsg>` to setup the basic DPDK environment.
 
 
+Runtime Config Options
+----------------------
+
+- ``rx_func_hint`` (default ``none``)
+
+  Used to select Rx burst function, supported value are "vec", "sve", "simple", "common".
+  When equal "vec" and meet the vector Rx usage condition then use the neon Rx function.
+  When equal "sve" and meet the sve Rx usage condition then use the sve Rx function.
+  When equal "simple" and meet the simple Rx usage condition then use the simple Rx function.
+  When equal "common" then use the common Rx function.
+
+- ``tx_func_hint`` (default ``none``)
+
+  Used to select Tx burst function, supported value are "vec", "sve", "simple", "common".
+  When equal "vec" and meet the vector Tx usage condition then use the neon Tx function.
+  When equal "sve" and meet the sve Tx usage condition then use the sve Tx function.
+  When equal "simple" and meet the simple Tx usage condition then use the simple Tx function.
+  When equal "common" then use the common Tx function.
+
+
 Driver compilation and testing
 ------------------------------
 
diff --git a/doc/guides/rel_notes/release_21_05.rst b/doc/guides/rel_notes/release_21_05.rst
index dc5399f..1d85942 100644
--- a/doc/guides/rel_notes/release_21_05.rst
+++ b/doc/guides/rel_notes/release_21_05.rst
@@ -60,6 +60,7 @@  New Features
   * Added support for module EEPROM dumping.
   * Added support for freeing Tx mbuf on demand.
   * Added support for copper port in Kunpeng930.
+  * Added support for runtime config to select IO burst function.
 
 * **Updated NXP DPAA2 driver.**
 
diff --git a/drivers/net/hns3/hns3_ethdev.c b/drivers/net/hns3/hns3_ethdev.c
index 9cbcc13..28aa27a 100644
--- a/drivers/net/hns3/hns3_ethdev.c
+++ b/drivers/net/hns3/hns3_ethdev.c
@@ -6,6 +6,7 @@ 
 #include <rte_bus_pci.h>
 #include <ethdev_pci.h>
 #include <rte_pci.h>
+#include <rte_kvargs.h>
 
 #include "hns3_ethdev.h"
 #include "hns3_logs.h"
@@ -6505,6 +6506,78 @@  hns3_get_module_info(struct rte_eth_dev *dev,
 	return 0;
 }
 
+static int
+hns3_parse_io_hint_func(const char *key, const char *value, void *extra_args)
+{
+	uint32_t hint = HNS3_IO_FUNC_HINT_NONE;
+
+	RTE_SET_USED(key);
+
+	if (strcmp(value, "vec") == 0)
+		hint = HNS3_IO_FUNC_HINT_VEC;
+	else if (strcmp(value, "sve") == 0)
+		hint = HNS3_IO_FUNC_HINT_SVE;
+	else if (strcmp(value, "simple") == 0)
+		hint = HNS3_IO_FUNC_HINT_SIMPLE;
+	else if (strcmp(value, "common") == 0)
+		hint = HNS3_IO_FUNC_HINT_COMMON;
+
+	/* If the hint is valid then update output parameters */
+	if (hint != HNS3_IO_FUNC_HINT_NONE)
+		*(uint32_t *)extra_args = hint;
+
+	return 0;
+}
+
+static const char *
+hns3_get_io_hint_func_name(uint32_t hint)
+{
+	switch (hint) {
+	case HNS3_IO_FUNC_HINT_VEC:
+		return "vec";
+	case HNS3_IO_FUNC_HINT_SVE:
+		return "sve";
+	case HNS3_IO_FUNC_HINT_SIMPLE:
+		return "simple";
+	case HNS3_IO_FUNC_HINT_COMMON:
+		return "common";
+	default:
+		return "none";
+	}
+}
+
+void
+hns3_parse_devargs(struct rte_eth_dev *dev)
+{
+	struct hns3_adapter *hns = dev->data->dev_private;
+	uint32_t rx_func_hint = HNS3_IO_FUNC_HINT_NONE;
+	uint32_t tx_func_hint = HNS3_IO_FUNC_HINT_NONE;
+	struct hns3_hw *hw = &hns->hw;
+	struct rte_kvargs *kvlist;
+
+	if (dev->device->devargs == NULL)
+		return;
+
+	kvlist = rte_kvargs_parse(dev->device->devargs->args, NULL);
+	if (!kvlist)
+		return;
+
+	rte_kvargs_process(kvlist, HNS3_DEVARG_RX_FUNC_HINT,
+			   &hns3_parse_io_hint_func, &rx_func_hint);
+	rte_kvargs_process(kvlist, HNS3_DEVARG_TX_FUNC_HINT,
+			   &hns3_parse_io_hint_func, &tx_func_hint);
+	rte_kvargs_free(kvlist);
+
+	if (rx_func_hint != HNS3_IO_FUNC_HINT_NONE)
+		hns3_warn(hw, "parsed %s = %s.", HNS3_DEVARG_RX_FUNC_HINT,
+			  hns3_get_io_hint_func_name(rx_func_hint));
+	hns->rx_func_hint = rx_func_hint;
+	if (tx_func_hint != HNS3_IO_FUNC_HINT_NONE)
+		hns3_warn(hw, "parsed %s = %s.", HNS3_DEVARG_TX_FUNC_HINT,
+			  hns3_get_io_hint_func_name(tx_func_hint));
+	hns->tx_func_hint = tx_func_hint;
+}
+
 static const struct eth_dev_ops hns3_eth_dev_ops = {
 	.dev_configure      = hns3_dev_configure,
 	.dev_start          = hns3_dev_start,
@@ -6625,6 +6698,7 @@  hns3_dev_init(struct rte_eth_dev *eth_dev)
 	hw->adapter_state = HNS3_NIC_UNINITIALIZED;
 	hns->is_vf = false;
 	hw->data = eth_dev->data;
+	hns3_parse_devargs(eth_dev);
 
 	/*
 	 * Set default max packet size according to the mtu
@@ -6758,5 +6832,8 @@  static struct rte_pci_driver rte_hns3_pmd = {
 RTE_PMD_REGISTER_PCI(net_hns3, rte_hns3_pmd);
 RTE_PMD_REGISTER_PCI_TABLE(net_hns3, pci_id_hns3_map);
 RTE_PMD_REGISTER_KMOD_DEP(net_hns3, "* igb_uio | vfio-pci");
+RTE_PMD_REGISTER_PARAM_STRING(net_hns3,
+		HNS3_DEVARG_RX_FUNC_HINT "=vec|sve|simple|common "
+		HNS3_DEVARG_TX_FUNC_HINT "=vec|sve|simple|common ");
 RTE_LOG_REGISTER(hns3_logtype_init, pmd.net.hns3.init, NOTICE);
 RTE_LOG_REGISTER(hns3_logtype_driver, pmd.net.hns3.driver, NOTICE);
diff --git a/drivers/net/hns3/hns3_ethdev.h b/drivers/net/hns3/hns3_ethdev.h
index 932600d..ec4b475 100644
--- a/drivers/net/hns3/hns3_ethdev.h
+++ b/drivers/net/hns3/hns3_ethdev.h
@@ -772,9 +772,23 @@  struct hns3_adapter {
 	bool tx_simple_allowed;
 	bool tx_vec_allowed;
 
+	uint32_t rx_func_hint;
+	uint32_t tx_func_hint;
+
 	struct hns3_ptype_table ptype_tbl __rte_cache_min_aligned;
 };
 
+enum {
+	HNS3_IO_FUNC_HINT_NONE = 0,
+	HNS3_IO_FUNC_HINT_VEC,
+	HNS3_IO_FUNC_HINT_SVE,
+	HNS3_IO_FUNC_HINT_SIMPLE,
+	HNS3_IO_FUNC_HINT_COMMON
+};
+
+#define HNS3_DEVARG_RX_FUNC_HINT	"rx_func_hint"
+#define HNS3_DEVARG_TX_FUNC_HINT	"tx_func_hint"
+
 #define HNS3_DEV_SUPPORT_DCB_B			0x0
 #define HNS3_DEV_SUPPORT_COPPER_B		0x1
 #define HNS3_DEV_SUPPORT_UDP_GSO_B		0x2
@@ -975,6 +989,7 @@  int hns3_dev_infos_get(struct rte_eth_dev *eth_dev,
 		       struct rte_eth_dev_info *info);
 void hns3vf_update_link_status(struct hns3_hw *hw, uint8_t link_status,
 			  uint32_t link_speed, uint8_t link_duplex);
+void hns3_parse_devargs(struct rte_eth_dev *dev);
 
 static inline bool
 is_reset_pending(struct hns3_adapter *hns)
diff --git a/drivers/net/hns3/hns3_ethdev_vf.c b/drivers/net/hns3/hns3_ethdev_vf.c
index fd20c52..f3eaefb 100644
--- a/drivers/net/hns3/hns3_ethdev_vf.c
+++ b/drivers/net/hns3/hns3_ethdev_vf.c
@@ -2834,6 +2834,7 @@  hns3vf_dev_init(struct rte_eth_dev *eth_dev)
 	hw->adapter_state = HNS3_NIC_UNINITIALIZED;
 	hns->is_vf = true;
 	hw->data = eth_dev->data;
+	hns3_parse_devargs(eth_dev);
 
 	ret = hns3_reset_init(hw);
 	if (ret)
@@ -2962,3 +2963,6 @@  static struct rte_pci_driver rte_hns3vf_pmd = {
 RTE_PMD_REGISTER_PCI(net_hns3_vf, rte_hns3vf_pmd);
 RTE_PMD_REGISTER_PCI_TABLE(net_hns3_vf, pci_id_hns3vf_map);
 RTE_PMD_REGISTER_KMOD_DEP(net_hns3_vf, "* igb_uio | vfio-pci");
+RTE_PMD_REGISTER_PARAM_STRING(net_hns3_vf,
+		HNS3_DEVARG_RX_FUNC_HINT "=vec|sve|simple|common "
+		HNS3_DEVARG_TX_FUNC_HINT "=vec|sve|simple|common ");
diff --git a/drivers/net/hns3/hns3_rxtx.c b/drivers/net/hns3/hns3_rxtx.c
index 00167c4..f5c7d71 100644
--- a/drivers/net/hns3/hns3_rxtx.c
+++ b/drivers/net/hns3/hns3_rxtx.c
@@ -2689,13 +2689,26 @@  hns3_get_rx_function(struct rte_eth_dev *dev)
 {
 	struct hns3_adapter *hns = dev->data->dev_private;
 	uint64_t offloads = dev->data->dev_conf.rxmode.offloads;
+	bool vec_allowed, sve_allowed, simple_allowed;
+
+	vec_allowed = hns->rx_vec_allowed &&
+		      hns3_rx_check_vec_support(dev) == 0;
+	sve_allowed = vec_allowed && hns3_check_sve_support();
+	simple_allowed = hns->rx_simple_allowed && !dev->data->scattered_rx &&
+			 (offloads & DEV_RX_OFFLOAD_TCP_LRO) == 0;
+
+	if (hns->rx_func_hint == HNS3_IO_FUNC_HINT_VEC && vec_allowed)
+		return hns3_recv_pkts_vec;
+	if (hns->rx_func_hint == HNS3_IO_FUNC_HINT_SVE && sve_allowed)
+		return hns3_recv_pkts_vec_sve;
+	if (hns->rx_func_hint == HNS3_IO_FUNC_HINT_SIMPLE && simple_allowed)
+		return hns3_recv_pkts;
+	if (hns->rx_func_hint == HNS3_IO_FUNC_HINT_COMMON)
+		return hns3_recv_scattered_pkts;
 
-	if (hns->rx_vec_allowed && hns3_rx_check_vec_support(dev) == 0)
-		return hns3_check_sve_support() ? hns3_recv_pkts_vec_sve :
-		       hns3_recv_pkts_vec;
-
-	if (hns->rx_simple_allowed && !dev->data->scattered_rx &&
-	    (offloads & DEV_RX_OFFLOAD_TCP_LRO) == 0)
+	if (vec_allowed)
+		return hns3_recv_pkts_vec;
+	if (simple_allowed)
 		return hns3_recv_pkts;
 
 	return hns3_recv_scattered_pkts;
@@ -3930,19 +3943,32 @@  hns3_get_tx_function(struct rte_eth_dev *dev, eth_tx_prep_t *prep)
 {
 	uint64_t offloads = dev->data->dev_conf.txmode.offloads;
 	struct hns3_adapter *hns = dev->data->dev_private;
+	bool vec_allowed, sve_allowed, simple_allowed;
 
-	if (hns->tx_vec_allowed && hns3_tx_check_vec_support(dev) == 0) {
-		*prep = NULL;
-		return hns3_check_sve_support() ? hns3_xmit_pkts_vec_sve :
-			hns3_xmit_pkts_vec;
-	}
+	vec_allowed = hns->tx_vec_allowed &&
+		      hns3_tx_check_vec_support(dev) == 0;
+	sve_allowed = vec_allowed && hns3_check_sve_support();
+	simple_allowed = hns->tx_simple_allowed &&
+			 offloads == (offloads & DEV_TX_OFFLOAD_MBUF_FAST_FREE);
 
-	if (hns->tx_simple_allowed &&
-	    offloads == (offloads & DEV_TX_OFFLOAD_MBUF_FAST_FREE)) {
-		*prep = NULL;
+	*prep = NULL;
+
+	if (hns->tx_func_hint == HNS3_IO_FUNC_HINT_VEC && vec_allowed)
+		return hns3_xmit_pkts_vec;
+	if (hns->tx_func_hint == HNS3_IO_FUNC_HINT_SVE && sve_allowed)
+		return hns3_xmit_pkts_vec_sve;
+	if (hns->tx_func_hint == HNS3_IO_FUNC_HINT_SIMPLE && simple_allowed)
 		return hns3_xmit_pkts_simple;
+	if (hns->tx_func_hint == HNS3_IO_FUNC_HINT_COMMON) {
+		*prep = hns3_prep_pkts;
+		return hns3_xmit_pkts;
 	}
 
+	if (vec_allowed)
+		return hns3_xmit_pkts_vec;
+	if (simple_allowed)
+		return hns3_xmit_pkts_simple;
+
 	*prep = hns3_prep_pkts;
 	return hns3_xmit_pkts;
 }