Skip to contentSkip to conversation

ethdev: make rte flow API thread safe

RFC In review Suanming Mou 3 participants 9 messages Sep 3, 2020 – Sep 24, 2020 Network drivers

lore
Share & tools
lore
#0 lore raw

RFC 1/1 ethdev: make rte flow API thread safe

Currently, the rte flow functions are not defined as thread safety. DPDK applications either call the functions in single thread or add locks around the functions for the critical section.

For PMDs support the flow operations thread safe natively, the redundant protection in application hurts the performance of the rte flow operation functions.

And the restriction of thread safety not guaranteed for the rte flow functions also limits the applications' expectation.

This feature is going to change the rte flow functions to be thread safety. As different PMDs have different flow operations, some may support thread safety already and others may not. For PMDs don't support flow thread safe operation, a new lock is defined in ethdev in order to protects thread unsafe PMDs from rte flow level.

A new RTE_ETH_DEV_FLOW_OPS_THREAD_SAFE device flag is added to determine whether the PMD supports thread safe flow operation or not. For PMDs support thread safe flow operations, set the RTE_ETH_DEV_FLOW_OPS_THREAD_SAFE flag, rte flow level functions will skip the thread safe helper lock for these PMDs. Again the rte flow level thread safe lock only works when PMD operation functions are not thread safety.

The change has no effect on the current DPDK applications. No change is required for the current DPDK applications.

---
 doc/guides/prog_guide/rte_flow.rst  |  7 ++--
 drivers/net/mlx5/linux/mlx5_os.c    |  5 +++
 lib/librte_ethdev/rte_ethdev.c      |  2 +
 lib/librte_ethdev/rte_ethdev.h      |  2 +
 lib/librte_ethdev/rte_ethdev_core.h |  1 +
 lib/librte_ethdev/rte_flow.c        | 84 ++++++++++++++++++++++++++++---------
 6 files changed, 78 insertions(+), 23 deletions(-)
doc/guides/prog_guide/rte_flow.rst +3 -4
index 3e5cd1e..54b592c 100644
@@ -3033,10 +3033,6 @@ Caveats
 - API operations are synchronous and blocking (``EAGAIN`` cannot be
   returned).
 
-- There is no provision for re-entrancy/multi-thread safety, although nothing
-  should prevent different devices from being configured at the same
-  time. PMDs may protect their control path functions accordingly.
-
 - Stopping the data path (TX/RX) should not be necessary when managing flow
   rules. If this cannot be achieved naturally or with workarounds (such as
   temporarily replacing the burst function pointers), an appropriate error
@@ -3088,6 +3084,9 @@ This interface additionally defines the following helper function:
 - ``rte_flow_ops_get()``: get generic flow operations structure from a
   port.
 
+If PMD interfaces do not support re-entrancy/multi-thread safety, rte flow
+level functions will do it by mutex.
+
 More will be added over time.
 
 Device compatibility
drivers/net/mlx5/linux/mlx5_os.c +5 -0
index 69123e1..872e868 100644
@@ -1152,6 +1152,11 @@
 	eth_dev->data->dev_private = priv;
 	priv->dev_data = eth_dev->data;
 	eth_dev->data->mac_addrs = priv->mac;
+	/*
+	 * This is an example of how to configure PMD flow thread safe.
+	 * Currently, mlx5 PMD still doesn't support thread safety.
+	 */
+	eth_dev->data->dev_flags = RTE_ETH_DEV_FLOW_OPS_THREAD_SAFE;
 	eth_dev->device = dpdk_dev;
 	/* Configure the first MAC address by default. */
 	if (mlx5_get_mac(eth_dev, &mac.addr_bytes)) {
lib/librte_ethdev/rte_ethdev.c +2 -0
index 7858ad5..8256657 100644
@@ -500,6 +500,7 @@ struct rte_eth_dev *
 	strlcpy(eth_dev->data->name, name, sizeof(eth_dev->data->name));
 	eth_dev->data->port_id = port_id;
 	eth_dev->data->mtu = RTE_ETHER_MTU;
+	pthread_mutex_init(&eth_dev->data->fts_mutex, NULL);
 
 unlock:
 	rte_spinlock_unlock(&rte_eth_dev_shared_data->ownership_lock);
@@ -562,6 +563,7 @@ struct rte_eth_dev *
 		rte_free(eth_dev->data->mac_addrs);
 		rte_free(eth_dev->data->hash_mac_addrs);
 		rte_free(eth_dev->data->dev_private);
+		pthread_mutex_destroy(&eth_dev->data->fts_mutex);
 		memset(eth_dev->data, 0, sizeof(struct rte_eth_dev_data));
 	}
 
lib/librte_ethdev/rte_ethdev.h +2 -0
index 70295d7..6ec2450 100644
@@ -1636,6 +1636,8 @@ struct rte_eth_dev_owner {
 #define RTE_ETH_DEV_REPRESENTOR  0x0010
 /** Device does not support MAC change after started */
 #define RTE_ETH_DEV_NOLIVE_MAC_ADDR  0x0020
+/** Device PMD supports thread safety flow operation */
+#define RTE_ETH_DEV_FLOW_OPS_THREAD_SAFE  0x0040
 
 /**
  * Iterates over valid ethdev ports owned by a specific owner.
lib/librte_ethdev/rte_ethdev_core.h +1 -0
index 32407dd..4d37124 100644
@@ -876,6 +876,7 @@ struct rte_eth_dev_data {
 			 *   Valid if RTE_ETH_DEV_REPRESENTOR in dev_flags.
 			 */
 
+	pthread_mutex_t fts_mutex; /**< rte flow ops thread safety mutex. */
 	uint64_t reserved_64s[4]; /**< Reserved for future fields */
 	void *reserved_ptrs[4];   /**< Reserved for future fields */
 } __rte_cache_aligned;
lib/librte_ethdev/rte_flow.c +65 -19

160 lines not on this page · raw message

Signature · 1 line
1.8.3.1
#1 lore raw
Quoted 25 lines · On Thu, 3 Sep 2020 12:53:02 +0800 Suanming Mou <[email protected]> wrote:

Currently, the rte flow functions are not defined as thread safety. DPDK applications either call the functions in single thread or add locks around the functions for the critical section.

For PMDs support the flow operations thread safe natively, the redundant protection in application hurts the performance of the rte flow operation functions.

And the restriction of thread safety not guaranteed for the rte flow functions also limits the applications' expectation.

This feature is going to change the rte flow functions to be thread safety. As different PMDs have different flow operations, some may support thread safety already and others may not. For PMDs don't support flow thread safe operation, a new lock is defined in ethdev in order to protects thread unsafe PMDs from rte flow level.

A new RTE_ETH_DEV_FLOW_OPS_THREAD_SAFE device flag is added to determine whether the PMD supports thread safe flow operation or not. For PMDs support thread safe flow operations, set the RTE_ETH_DEV_FLOW_OPS_THREAD_SAFE flag, rte flow level functions will skip the thread safe helper lock for these PMDs. Again the rte flow level thread safe lock only works when PMD operation functions are not thread safety.

Quoted 4 lines

The change has no effect on the current DPDK applications. No change is required for the current DPDK applications.

What is the performance impact of this for currently working applications that use a single thread to program flow rules. You are adding a couple of system calls to what was formerly a totally usermode operation.

#2 lore raw

Hi,

Sorry for my late reply due to the vacation.

Quoted 3 lines

What is the performance impact of this for currently working applications that use a single thread to program flow rules. You are adding a couple of system calls to what was formerly a totally usermode operation.

If I understand correctly, in the non-contended single thread case, pthread mutex lock should not go to the kernel space. I also wrote a small application with pthread mutex, and strace shows no system call was introduced.

Another simple testing code below is to check the cycles cost difference in every round between pthread mutex and spin_lock.

//#define FT_USE_SPIN 1
#define NLOOP 1000000

#ifdef FT_USE_SPIN
static rte_spinlock_t sp_lock;
#else
static pthread_mutex_t ml_lock;
#endif

static inline void ft_init_lock(void)
{

#ifdef FT_USE_SPIN
	rte_spinlock_init(&sp_lock);
#else
	pthread_mutex_init(&ml_lock, NULL);

#endif
}

static inline void ft_unlock(void)
{

#ifdef FT_USE_SPIN
	rte_spinlock_unlock(&sp_lock);
#else
	pthread_mutex_unlock(&ml_lock);

#endif
}

static inline void ft_lock(void)
{

#ifdef FT_USE_SPIN
	rte_spinlock_lock(&sp_lock);
#else
	pthread_mutex_lock(&ml_lock);

#endif
}

static void ft_check_cycles(void)

{
	static int init = 0;
	uint64_t start, end;
	int i, n;

	if (!init) {
		init = 1;
		ft_init_lock();
	}

	/* Make code hot. */
	ft_lock();
	n = 0;
	ft_unlock();

	start = rte_rdtsc();
	for (i = 0; i < NLOOP; i++) {
		ft_lock();
		n++;
		ft_unlock();
	}
	end = rte_rdtsc();
	printf("loop:%d, cycles per loop:%f\n", n, (end - start) / (float)n);
}

They both showed around 50 cycles similar costing per loop.

The reason pthread mutex lock chosen here is that most DPDK applications like OVS-DPDK is using that.

Thanks,
SuanmingMou

#3 lore raw
Quoted 8 lines · On Mon, 7 Sep 2020 02:36:48 +0000 Suanming Mou <[email protected]> wrote:

Hi,

Sorry for my late reply due to the vacation.

Quoted 3 lines

What is the performance impact of this for currently working applications that use a single thread to program flow rules. You are adding a couple of system calls to what was formerly a totally usermode operation.

Read the source for glibc and see what pthread_mutex does

Quoted 5 lines

If I understand correctly, in the non-contended single thread case, pthread mutex lock should not go to the kernel space. I also wrote a small application with pthread mutex, and strace shows no system call was introduced.

Another simple testing code below is to check the cycles cost difference in every round between pthread mutex and spin_lock.

Micro benchmarks of locking is hard to see.

#4 lore raw

08/09/2020 16:52, Stephen Hemminger:

Quoted 7 lines
Quoted 3 lines · On Mon, 7 Sep 2020 02:36:48 +0000 Suanming Mou <[email protected]> wrote:
Quoted 3 lines

What is the performance impact of this for currently working applications that use a single thread to program flow rules. You are adding a couple of system calls to what was formerly a totally usermode operation.

Read the source for glibc and see what pthread_mutex does

What would be the best lock for rte_flow?
We have spin lock, ticket lock, MCS lock (and rwlock) in DPDK.

Quoted 6 lines
Quoted 4 lines

If I understand correctly, in the non-contended single thread case, pthread mutex lock should not go to the kernel space. I also wrote a small application with pthread mutex, and strace shows no system call was introduced.

Another simple testing code below is to check the cycles cost difference in every round between pthread mutex and spin_lock.

Micro benchmarks of locking is hard to see.

#5 lore raw
Quoted 11 lines · On Tue, 08 Sep 2020 17:03:53 +0200 Thomas Monjalon <[email protected]> wrote:

08/09/2020 16:52, Stephen Hemminger:

Quoted 7 lines
Quoted 3 lines · On Mon, 7 Sep 2020 02:36:48 +0000 Suanming Mou <[email protected]> wrote:
Quoted 3 lines

What is the performance impact of this for currently working applications that use a single thread to program flow rules. You are adding a couple of system calls to what was formerly a totally usermode operation.

Read the source for glibc and see what pthread_mutex does

What would be the best lock for rte_flow?
We have spin lock, ticket lock, MCS lock (and rwlock) in DPDK.

The tradeoff is between speed, correctness, and simplicity. The flow case is performance sensitive (for connection per second tests); but not super critical (ie every packet).
Fastest would be RCU but probably not necessary here.

There would rarely be contention on this (thread safety is new), and there is no case where reader makes sense. For hardware, programming flow rules would basic interaction with TCAM (ie fast). For software drivers, typically making flow rule requires system call to set classifier etc. Holding spin lock across system calls leads to preemption and other issues.

Would it be possible to push the choice of mutual exclusion down to the device driver? For fast HW devices they could use spinlock and for slow SW devices it would be pthread.

#6 lore raw
Quoted 35 lines

-----Original Message-----
From: Stephen Hemminger <[email protected]>
Sent: Wednesday, September 9, 2020 12:03 AM
To: NBU-Contact-Thomas Monjalon <[email protected]>
Cc: Suanming Mou <[email protected]>; Ori Kam <[email protected]>; Matan Azrad <[email protected]>; Shahaf Shuler <[email protected]>; Viacheslav Ovsiienko <[email protected]>; Ferruh Yigit <[email protected]>; Andrew Rybchenko <[email protected]>; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]
Subject: Re: [dpdk-dev] [RFC] ethdev: make rte flow API thread safe

Quoted 5 lines · On Tue, 08 Sep 2020 17:03:53 +0200 Thomas Monjalon <[email protected]> wrote:

08/09/2020 16:52, Stephen Hemminger:

Quoted 4 lines
Quoted 2 lines · On Mon, 7 Sep 2020 02:36:48 +0000 Suanming Mou <[email protected]> wrote:
Quoted 2 lines

What is the performance impact of this for currently working applications that use a single thread to program flow rules. You are

adding a couple of system

Quoted 6 lines
Quoted 3 lines
Quoted 1 line
Quoted 1 line

calls to what was formerly a totally usermode operation.

Read the source for glibc and see what pthread_mutex does

What would be the best lock for rte_flow?
We have spin lock, ticket lock, MCS lock (and rwlock) in DPDK.

The tradeoff is between speed, correctness, and simplicity.
The flow case is performance sensitive (for connection per second tests); but not super critical (ie every packet).
Fastest would be RCU but probably not necessary here.

Quoted 5 lines

There would rarely be contention on this (thread safety is new), and there is no case where reader makes sense. For hardware, programming flow rules would basic interaction with TCAM (ie fast). For software drivers, typically making flow rule requires system call to set classifier etc. Holding spin lock across system calls leads to preemption and other issues.

Very good explanation, thank you Stephen. Totally agree with that.

Quoted 4 lines

Would it be possible to push the choice of mutual exclusion down to the device driver? For fast HW devices they could use spinlock and for slow SW devices it would be pthread.

That's a good hint. But that will also introduce the vendor PMD to update. I tried to list some points here.
1. For single thread case, pthread mutex acts similar as spinlock, spinlock or pthread mutex will not make difference here.
2. For multiple threads lock contention, spinlock will introduce more CPU usage. DPDK applications currently use mutex later get rid of the outer mutex will suffer higher CPU usage with the spinlock(fast hardware PMD).

And one more general question, can we find some DPDK applications now use spinlock with the rte flow APIs?

#7 lore raw

Hi,

Quoted 25 lines

-----Original Message-----
From: Suanming Mou
Sent: Wednesday, September 9, 2020 10:26 AM
To: Stephen Hemminger <[email protected]>; NBU-Contact- Thomas Monjalon <[email protected]>
Cc: Ori Kam <[email protected]>; Matan Azrad <[email protected]>; Shahaf Shuler <[email protected]>; Viacheslav Ovsiienko <[email protected]>; Ferruh Yigit <[email protected]>; Andrew Rybchenko <[email protected]>; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]
Subject: RE: [dpdk-dev] [RFC] ethdev: make rte flow API thread safe

Quoted 3 lines

Would it be possible to push the choice of mutual exclusion down to the device driver? For fast HW devices they could use spinlock and for slow SW devices it would be pthread.

That's a good hint. But that will also introduce the vendor PMD to update. I tried to list some points here.
1. For single thread case, pthread mutex acts similar as spinlock, spinlock or pthread mutex will not make difference here.
2. For multiple threads lock contention, spinlock will introduce more CPU usage. DPDK applications currently use mutex later get rid of the outer mutex will suffer higher CPU usage with the spinlock(fast hardware PMD).

Quoted 2 lines

And one more general question, can we find some DPDK applications now use spinlock with the rte flow APIs?

Since there's no other suggestions regarding lock chosen, maybe we can keep the default mutex lock in rte flow functions.
For the fast HW devices case as Stephen wrote, these fast HW device PMDs can set the RTE_ETH_DEV_FLOW_OPS_THREAD_SAFE flag, and add the spinlock in the PMD to replace the mutex lock in rte flow functions. Similarly, if some PMDs prefer other types of lock, just set the RTE_ETH_DEV_FLOW_OPS_THREAD_SAFE flag, and add the needed type of lock to PMD internal.
The default mutex lock in rte flow functions will be replaced easily.
How do you feel like this?

Thanks,
SuanmingMou

#8 lore raw
In reply to Stephen Hemminger
Quoted 21 lines

-----Original Message-----
From: Stephen Hemminger <[email protected]>
Sent: Tuesday, September 8, 2020 10:52 PM
To: Suanming Mou <[email protected]>
Cc: Ori Kam <[email protected]>; John McNamara <[email protected]>; Marko Kovacevic <[email protected]>; Matan Azrad <[email protected]>; Shahaf Shuler <[email protected]>; Viacheslav Ovsiienko <[email protected]>; NBU-Contact-Thomas Monjalon <[email protected]>; Ferruh Yigit <[email protected]>; Andrew Rybchenko <[email protected]>; [email protected]
Subject: Re: [dpdk-dev] [RFC] ethdev: make rte flow API thread safe

Quoted 4 lines · On Mon, 7 Sep 2020 02:36:48 +0000 Suanming Mou <[email protected]> wrote:

Hi,

Sorry for my late reply due to the vacation.

Quoted 7 lines
Quoted 3 lines
Quoted 3 lines

What is the performance impact of this for currently working applications that use a single thread to program flow rules. You are adding a couple of system calls to what was formerly a totally usermode

operation.

Quoted 1 line

Read the source for glibc and see what pthread_mutex does

Yes, the pthread mutex lock will try CAS(Compare And Swap) with the atomic value first, if not success, have the futex syscall. So it means in single thread case, no syscall will be introduced. And the testing code also shows pthread mutex have similar cycles with spin_lock.

Quoted 11 lines
Quoted 2 lines

If I understand correctly, in the non-contended single thread case, pthread

mutex lock should not go to the kernel space.

Quoted 1 line

I also wrote a small application with pthread mutex, and strace shows no

system call was introduced.

Quoted 2 lines

Another simple testing code below is to check the cycles cost difference in

every round between pthread mutex and spin_lock.

Quoted 1 line

Micro benchmarks of locking is hard to see.