Skip to contentSkip to conversation

event/dlb2: add support for single 512B write of 4 QEs

PATCH Superseded Timothy McDaniel 3 participants 20 messages Apr 9, 2022 – Jun 14, 2022 Arm/Amlogic Meson SoC support

lore
Share & tools
lore
#0 lore raw

PATCH 1/1 event/dlb2: add support for single 512B write of 4 QEs

On Xeon, as 512b accesses are available, movdir64 instruction is able to perform 512b read and write to DLB producer port. In order for movdir64 to be able to pull its data from store buffers (store-buffer-forwarding) (before actual write), data should be in single 512b write format. This commit add change when code is built for Xeon with 512b AVX support to make single 512b write of all 4 QEs instead of 4x64b writes.

---
 drivers/event/dlb2/dlb2.c | 86 ++++++++++++++++++++++++++++++---------
 1 file changed, 67 insertions(+), 19 deletions(-)
drivers/event/dlb2/dlb2.c +67 -19
index 36f07d0061..e2a5303310 100644
@@ -2776,25 +2776,73 @@ dlb2_event_build_hcws(struct dlb2_port *qm_port,
 						ev[3].event_type,
 					     DLB2_QE_EV_TYPE_WORD + 4);
 
-		/* Store the metadata to memory (use the double-precision
-		 * _mm_storeh_pd because there is no integer function for
-		 * storing the upper 64b):
-		 * qe[0] metadata = sse_qe[0][63:0]
-		 * qe[1] metadata = sse_qe[0][127:64]
-		 * qe[2] metadata = sse_qe[1][63:0]
-		 * qe[3] metadata = sse_qe[1][127:64]
-		 */
-		_mm_storel_epi64((__m128i *)&qe[0].u.opaque_data, sse_qe[0]);
-		_mm_storeh_pd((double *)&qe[1].u.opaque_data,
-			      (__m128d)sse_qe[0]);
-		_mm_storel_epi64((__m128i *)&qe[2].u.opaque_data, sse_qe[1]);
-		_mm_storeh_pd((double *)&qe[3].u.opaque_data,
-			      (__m128d)sse_qe[1]);
-
-		qe[0].data = ev[0].u64;
-		qe[1].data = ev[1].u64;
-		qe[2].data = ev[2].u64;
-		qe[3].data = ev[3].u64;
+ #ifdef __AVX512VL__
+
+			/*
+			 * 1) Build avx512 QE store and build each
+			 *    QE individually as XMM register
+			 * 2) Merge the 4 XMM registers/QEs into single AVX512
+			 *    register
+			 * 3) Store single avx512 register to &qe[0] (4x QEs
+			 *    stored in 1x store)
+			 */
+
+			__m128i v_qe0 = _mm_setzero_si128();
+			uint64_t meta = _mm_extract_epi64(sse_qe[0], 0);
+			v_qe0 = _mm_insert_epi64(v_qe0, ev[0].u64, 0);
+			v_qe0 = _mm_insert_epi64(v_qe0, meta, 1);
+
+			__m128i v_qe1 = _mm_setzero_si128();
+			meta = _mm_extract_epi64(sse_qe[0], 1);
+			v_qe1 = _mm_insert_epi64(v_qe1, ev[1].u64, 0);
+			v_qe1 = _mm_insert_epi64(v_qe1, meta, 1);
+
+			__m128i v_qe2 = _mm_setzero_si128();
+			meta = _mm_extract_epi64(sse_qe[1], 0);
+			v_qe2 = _mm_insert_epi64(v_qe2, ev[2].u64, 0);
+			v_qe2 = _mm_insert_epi64(v_qe2, meta, 1);
+
+			__m128i v_qe3 = _mm_setzero_si128();
+			meta = _mm_extract_epi64(sse_qe[1], 1);
+			v_qe3 = _mm_insert_epi64(v_qe3, ev[3].u64, 0);
+			v_qe3 = _mm_insert_epi64(v_qe3, meta, 1);
+
+			/* we have 4x XMM registers, one per QE. */
+			__m512i v_all_qes = _mm512_setzero_si512();
+			v_all_qes = _mm512_inserti32x4(v_all_qes, v_qe0, 0);
+			v_all_qes = _mm512_inserti32x4(v_all_qes, v_qe1, 1);
+			v_all_qes = _mm512_inserti32x4(v_all_qes, v_qe2, 2);
+			v_all_qes = _mm512_inserti32x4(v_all_qes, v_qe3, 3);
+
+			/*
+			 * store the 4x QEs in a single register to the scratch
+			 * space of the PMD
+			 */
+			_mm512_store_si512(&qe[0], v_all_qes);
+#else
+			/*
+			 * Store the metadata to memory (use the double-precision
+			 * _mm_storeh_pd because there is no integer function for
+			 * storing the upper 64b):
+			 * qe[0] metadata = sse_qe[0][63:0]
+			 * qe[1] metadata = sse_qe[0][127:64]
+			 * qe[2] metadata = sse_qe[1][63:0]
+			 * qe[3] metadata = sse_qe[1][127:64]
+			 */
+			_mm_storel_epi64((__m128i *)&qe[0].u.opaque_data,
+					 sse_qe[0]);
+			_mm_storeh_pd((double *)&qe[1].u.opaque_data,
+				      (__m128d)sse_qe[0]);
+			_mm_storel_epi64((__m128i *)&qe[2].u.opaque_data,
+					 sse_qe[1]);
+			_mm_storeh_pd((double *)&qe[3].u.opaque_data,
+				      (__m128d)sse_qe[1]);
+
+			qe[0].data = ev[0].u64;
+			qe[1].data = ev[1].u64;
+			qe[2].data = ev[2].u64;
+			qe[3].data = ev[3].u64;
+#endif
 
 		break;
 	case 3:
Signature · 1 line
2.25.1
#1 lore raw
Quoted 31 lines · Timothy McDaniel

On Xeon, as 512b accesses are available, movdir64 instruction is able to perform 512b read and write to DLB producer port. In order for movdir64 to be able to pull its data from store buffers (store-buffer-forwarding) (before actual write), data should be in single 512b write format. This commit add change when code is built for Xeon with 512b AVX support to make single 512b write of all 4 QEs instead of 4x64b writes.

---
 drivers/event/dlb2/dlb2.c | 86 ++++++++++++++++++++++++++++++---------
 1 file changed, 67 insertions(+), 19 deletions(-)
drivers/event/dlb2/dlb2.c +0 -10
index 36f07d0061..e2a5303310 100644
@@ -2776,25 +2776,73 @@ dlb2_event_build_hcws(struct dlb2_port *qm_port,
                                                ev[3].event_type,
                                             DLB2_QE_EV_TYPE_WORD + 4);
 
-               /* Store the metadata to memory (use the double-precision
-                * _mm_storeh_pd because there is no integer function for
-                * storing the upper 64b):
-                * qe[0] metadata = sse_qe[0][63:0]
-                * qe[1] metadata = sse_qe[0][127:64]
-                * qe[2] metadata = sse_qe[1][63:0]
-                * qe[3] metadata = sse_qe[1][127:64]
-                */
-               _mm_storel_epi64((__m128i *)&qe[0].u.opaque_data, sse_qe[0]);
-               _mm_storeh_pd((double *)&qe[1].u.opaque_data,

drivers/event/dlb2/dlb2.c dlb2_event_build_hcws(struct dlb2_port *qm_port, · line 2779

Quoted 10 lines
drivers/event/dlb2/dlb2.c +1 -9
-                             (__m128d)sse_qe[0]);
-               _mm_storel_epi64((__m128i *)&qe[2].u.opaque_data, sse_qe[1]);
-               _mm_storeh_pd((double *)&qe[3].u.opaque_data,
-                             (__m128d)sse_qe[1]);
-
-               qe[0].data = ev[0].u64;
-               qe[1].data = ev[1].u64;
-               qe[2].data = ev[2].u64;
-               qe[3].data = ev[3].u64;
+ #ifdef __AVX512VL__

+ x86 maintainers

We need a runtime check based on CPU flags. Right? As the build and run machine can be different?

Quoted 72 lines
drivers/event/dlb2/dlb2.c +66 -1
+
+                       /*
+                        * 1) Build avx512 QE store and build each
+                        *    QE individually as XMM register
+                        * 2) Merge the 4 XMM registers/QEs into single AVX512
+                        *    register
+                        * 3) Store single avx512 register to &qe[0] (4x QEs
+                        *    stored in 1x store)
+                        */
+
+                       __m128i v_qe0 = _mm_setzero_si128();
+                       uint64_t meta = _mm_extract_epi64(sse_qe[0], 0);
+                       v_qe0 = _mm_insert_epi64(v_qe0, ev[0].u64, 0);
+                       v_qe0 = _mm_insert_epi64(v_qe0, meta, 1);
+
+                       __m128i v_qe1 = _mm_setzero_si128();
+                       meta = _mm_extract_epi64(sse_qe[0], 1);
+                       v_qe1 = _mm_insert_epi64(v_qe1, ev[1].u64, 0);
+                       v_qe1 = _mm_insert_epi64(v_qe1, meta, 1);
+
+                       __m128i v_qe2 = _mm_setzero_si128();
+                       meta = _mm_extract_epi64(sse_qe[1], 0);
+                       v_qe2 = _mm_insert_epi64(v_qe2, ev[2].u64, 0);
+                       v_qe2 = _mm_insert_epi64(v_qe2, meta, 1);
+
+                       __m128i v_qe3 = _mm_setzero_si128();
+                       meta = _mm_extract_epi64(sse_qe[1], 1);
+                       v_qe3 = _mm_insert_epi64(v_qe3, ev[3].u64, 0);
+                       v_qe3 = _mm_insert_epi64(v_qe3, meta, 1);
+
+                       /* we have 4x XMM registers, one per QE. */
+                       __m512i v_all_qes = _mm512_setzero_si512();
+                       v_all_qes = _mm512_inserti32x4(v_all_qes, v_qe0, 0);
+                       v_all_qes = _mm512_inserti32x4(v_all_qes, v_qe1, 1);
+                       v_all_qes = _mm512_inserti32x4(v_all_qes, v_qe2, 2);
+                       v_all_qes = _mm512_inserti32x4(v_all_qes, v_qe3, 3);
+
+                       /*
+                        * store the 4x QEs in a single register to the scratch
+                        * space of the PMD
+                        */
+                       _mm512_store_si512(&qe[0], v_all_qes);
+#else
+                       /*
+                        * Store the metadata to memory (use the double-precision
+                        * _mm_storeh_pd because there is no integer function for
+                        * storing the upper 64b):
+                        * qe[0] metadata = sse_qe[0][63:0]
+                        * qe[1] metadata = sse_qe[0][127:64]
+                        * qe[2] metadata = sse_qe[1][63:0]
+                        * qe[3] metadata = sse_qe[1][127:64]
+                        */
+                       _mm_storel_epi64((__m128i *)&qe[0].u.opaque_data,
+                                        sse_qe[0]);
+                       _mm_storeh_pd((double *)&qe[1].u.opaque_data,
+                                     (__m128d)sse_qe[0]);
+                       _mm_storel_epi64((__m128i *)&qe[2].u.opaque_data,
+                                        sse_qe[1]);
+                       _mm_storeh_pd((double *)&qe[3].u.opaque_data,
+                                     (__m128d)sse_qe[1]);
+
+                       qe[0].data = ev[0].u64;
+                       qe[1].data = ev[1].u64;
+                       qe[2].data = ev[2].u64;
+                       qe[3].data = ev[3].u64;
+#endif
 
                break;
        case 3:
--

2.25.1

#2 lore raw
Quoted 38 lines · Jerin Jacob
Quoted 19 lines · Timothy McDaniel

On Xeon, as 512b accesses are available, movdir64 instruction is able to perform 512b read and write to DLB producer port. In order for movdir64 to be able to pull its data from store buffers (store-buffer-forwarding) (before actual write), data should be in single 512b write format. This commit add change when code is built for Xeon with 512b AVX support to make single 512b write of all 4 QEs instead of 4x64b writes.

drivers/event/dlb2/dlb2.c | 86 ++++++++++++++++++++++++++++++---------

1 file changed, 67 insertions(+), 19 deletions(-)
drivers/event/dlb2/dlb2.c +0 -0
index 36f07d0061..e2a5303310 100644 --- a/drivers/event/dlb2/dlb2.c +++

b/drivers/event/dlb2/dlb2.c @@ -2776,25 +2776,73 @@ dlb2_event_build_hcws(struct dlb2_port *qm_port, ev[3].event_type, DLB2_QE_EV_TYPE_WORD + 4);

Quoted 14 lines

- /* Store the metadata to memory (use the
double-precision - * _mm_storeh_pd because there is no
integer function for - * storing the upper 64b): -
* qe[0] metadata = sse_qe[0][63:0] - * qe[1] metadata =
sse_qe[0][127:64] - * qe[2] metadata = sse_qe[1][63:0] -
* qe[3] metadata = sse_qe[1][127:64] - */ -
_mm_storel_epi64((__m128i *)&qe[0].u.opaque_data, sse_qe[0]); - _mm_storeh_pd((double *)&qe[1].u.opaque_data, -
(__m128d)sse_qe[0]); - _mm_storel_epi64((__m128i
*)&qe[2].u.opaque_data, sse_qe[1]); - _mm_storeh_pd((double *)&qe[3].u.opaque_data, -
(__m128d)sse_qe[1]); - - qe[0].data = ev[0].u64; -
qe[1].data = ev[1].u64; - qe[2].data = ev[2].u64; -
qe[3].data = ev[3].u64; + #ifdef __AVX512VL__

+ x86 maintainers

Quoted 3 lines

We need a runtime check based on CPU flags. Right? As the build and run machine can be different?

Ideally, yes, this should be a run-time decision. There are quite a number of examples of this in DPDK. However, most uses of runtime decisions are in functions called via function pointer, so not sure if those schemes apply here. It's certainly worth investigating, though.

/Bruce

#3 lore raw
In reply to Jerin Jacob
Quoted 55 lines

-----Original Message-----
From: Jerin Jacob <[email protected]>
Sent: Saturday, May 14, 2022 7:08 AM
To: McDaniel, Timothy <[email protected]>; Richardson, Bruce <[email protected]>; [email protected]
Cc: Jerin Jacob <[email protected]>; dpdk-dev <[email protected]>
Subject: Re: [PATCH] event/dlb2: add support for single 512B write of 4 QEs

drivers/event/dlb2/dlb2.c dlb2_event_build_hcws(struct dlb2_port

Quoted 18 lines · Timothy McDaniel

On Xeon, as 512b accesses are available, movdir64 instruction is able to perform 512b read and write to DLB producer port. In order for movdir64 to be able to pull its data from store buffers (store-buffer-forwarding) (before actual write), data should be in single 512b write format. This commit add change when code is built for Xeon with 512b AVX support to make single 512b write of all 4 QEs instead of 4x64b writes.

---
 drivers/event/dlb2/dlb2.c | 86 ++++++++++++++++++++++++++++++---------
 1 file changed, 67 insertions(+), 19 deletions(-)
drivers/event/dlb2/dlb2.c +0 -0
index 36f07d0061..e2a5303310 100644
@@ -2776,25 +2776,73 @@ dlb2_event_build_hcws(struct dlb2_port

*qm_port,

Quoted 13 lines
drivers/event/dlb2/dlb2.c +0 -10
                                                ev[3].event_type,
                                             DLB2_QE_EV_TYPE_WORD + 4);
 
-               /* Store the metadata to memory (use the double-precision
-                * _mm_storeh_pd because there is no integer function for
-                * storing the upper 64b):
-                * qe[0] metadata = sse_qe[0][63:0]
-                * qe[1] metadata = sse_qe[0][127:64]
-                * qe[2] metadata = sse_qe[1][63:0]
-                * qe[3] metadata = sse_qe[1][127:64]
-                */
-               _mm_storel_epi64((__m128i *)&qe[0].u.opaque_data, sse_qe[0]);
-               _mm_storeh_pd((double *)&qe[1].u.opaque_data,

drivers/event/dlb2/dlb2.c dlb2_event_build_hcws(struct dlb2_port *qm_port, · line 2779

Quoted 10 lines
drivers/event/dlb2/dlb2.c +1 -9
-                             (__m128d)sse_qe[0]);
-               _mm_storel_epi64((__m128i *)&qe[2].u.opaque_data, sse_qe[1]);
-               _mm_storeh_pd((double *)&qe[3].u.opaque_data,
-                             (__m128d)sse_qe[1]);
-
-               qe[0].data = ev[0].u64;
-               qe[1].data = ev[1].u64;
-               qe[2].data = ev[2].u64;
-               qe[3].data = ev[3].u64;
+ #ifdef __AVX512VL__
Quoted 4 lines

+ x86 maintainers

We need a runtime check based on CPU flags. Right? As the build and run machine can be different?

Thanks Jerin. I will convert to a runtime check.

#4 lore raw

PATCH v3 1/1 event/dlb2: add support for single 512B write of 4 QEs

In reply to Timothy McDaniel

On Xeon, as 512b accesses are available, movdir64 instruction is able to perform 512b read and write to DLB producer port. In order for movdir64 to be able to pull its data from store buffers (store-buffer-forwarding) (before actual write), data should be in single 512b write format. This commit add change when code is built for Xeon with 512b AVX support to make single 512b write of all 4 QEs instead of 4x64b writes.

===

Changes since V1:
1) Split out dlb2_event_build_hcws into two implementations, one that uses AVX512 instructions, and one that does not. Each implementation is in its own source file in order to avoid build errors if the compiler does not support the newer AVX512 instructions.
2) Update meson.build to and pull in appropriate source file based on whether the compiler supports AVX512VL
3) Check if target supports AVX512VL, and use appropriate implementation based on this runtime check.

---
 drivers/event/dlb2/dlb2.c          | 206 +---------------------
 drivers/event/dlb2/dlb2_avx512.c   | 267 +++++++++++++++++++++++++++++
 drivers/event/dlb2/dlb2_noavx512.c | 219 +++++++++++++++++++++++
 drivers/event/dlb2/dlb2_priv.h     |   8 +
 drivers/event/dlb2/meson.build     |  14 ++
 5 files changed, 513 insertions(+), 201 deletions(-)
 create mode 100644 drivers/event/dlb2/dlb2_avx512.c
 create mode 100644 drivers/event/dlb2/dlb2_noavx512.c
drivers/event/dlb2/dlb2.c +5 -201
index 36f07d0061..ac7572a28d 100644
@@ -1834,6 +1834,11 @@ dlb2_eventdev_port_setup(struct rte_eventdev *dev,
 
 	dev->data->ports[ev_port_id] = &dlb2->ev_ports[ev_port_id];
 
+	if (rte_cpu_get_flag_enabled(RTE_CPUFLAG_AVX512VL))
+		ev_port->qm_port.use_avx512 = true;
+	else
+		ev_port->qm_port.use_avx512 = false;
+
 	return 0;
 }
 
@@ -2430,21 +2435,6 @@ dlb2_eventdev_start(struct rte_eventdev *dev)
 	return 0;
 }
 
-static uint8_t cmd_byte_map[DLB2_NUM_PORT_TYPES][DLB2_NUM_HW_SCHED_TYPES] = {
-	{
-		/* Load-balanced cmd bytes */
-		[RTE_EVENT_OP_NEW] = DLB2_NEW_CMD_BYTE,
-		[RTE_EVENT_OP_FORWARD] = DLB2_FWD_CMD_BYTE,
-		[RTE_EVENT_OP_RELEASE] = DLB2_COMP_CMD_BYTE,
-	},
-	{
-		/* Directed cmd bytes */
-		[RTE_EVENT_OP_NEW] = DLB2_NEW_CMD_BYTE,
-		[RTE_EVENT_OP_FORWARD] = DLB2_NEW_CMD_BYTE,
-		[RTE_EVENT_OP_RELEASE] = DLB2_NOOP_CMD_BYTE,
-	},
-};
-
 static inline uint32_t
 dlb2_port_credits_get(struct dlb2_port *qm_port,
 		      enum dlb2_hw_queue_types type)
@@ -2639,192 +2629,6 @@ dlb2_construct_token_pop_qe(struct dlb2_port *qm_port, int idx)
 	qm_port->owed_tokens = 0;
 }
 
-static inline void
-dlb2_event_build_hcws(struct dlb2_port *qm_port,
-		      const struct rte_event ev[],
-		      int num,
-		      uint8_t *sched_type,
-		      uint8_t *queue_id)
-{
-	struct dlb2_enqueue_qe *qe;
-	uint16_t sched_word[4];
-	__m128i sse_qe[2];
-	int i;
-
-	qe = qm_port->qe4;
-
-	sse_qe[0] = _mm_setzero_si128();
-	sse_qe[1] = _mm_setzero_si128();
-
-	switch (num) {
-	case 4:
-		/* Construct the metadata portion of two HCWs in one 128b SSE
-		 * register. HCW metadata is constructed in the SSE registers
-		 * like so:
-		 * sse_qe[0][63:0]:   qe[0]'s metadata
-		 * sse_qe[0][127:64]: qe[1]'s metadata
-		 * sse_qe[1][63:0]:   qe[2]'s metadata
-		 * sse_qe[1][127:64]: qe[3]'s metadata
-		 */
-
-		/* Convert the event operation into a command byte and store it
-		 * in the metadata:
-		 * sse_qe[0][63:56]   = cmd_byte_map[is_directed][ev[0].op]
-		 * sse_qe[0][127:120] = cmd_byte_map[is_directed][ev[1].op]
-		 * sse_qe[1][63:56]   = cmd_byte_map[is_directed][ev[2].op]
-		 * sse_qe[1][127:120] = cmd_byte_map[is_directed][ev[3].op]
-		 */
-#define DLB2_QE_CMD_BYTE 7
-		sse_qe[0] = _mm_insert_epi8(sse_qe[0],
-				cmd_byte_map[qm_port->is_directed][ev[0].op],
-				DLB2_QE_CMD_BYTE);
-		sse_qe[0] = _mm_insert_epi8(sse_qe[0],
-				cmd_byte_map[qm_port->is_directed][ev[1].op],
-				DLB2_QE_CMD_BYTE + 8);
-		sse_qe[1] = _mm_insert_epi8(sse_qe[1],
-				cmd_byte_map[qm_port->is_directed][ev[2].op],
-				DLB2_QE_CMD_BYTE);
-		sse_qe[1] = _mm_insert_epi8(sse_qe[1],
-				cmd_byte_map[qm_port->is_directed][ev[3].op],
-				DLB2_QE_CMD_BYTE + 8);
-
-		/* Store priority, scheduling type, and queue ID in the sched
-		 * word array because these values are re-used when the
-		 * destination is a directed queue.
-		 */
-		sched_word[0] = EV_TO_DLB2_PRIO(ev[0].priority) << 10 |
-				sched_type[0] << 8 |
-				queue_id[0];
-		sched_word[1] = EV_TO_DLB2_PRIO(ev[1].priority) << 10 |
-				sched_type[1] << 8 |
-				queue_id[1];
-		sched_word[2] = EV_TO_DLB2_PRIO(ev[2].priority) << 10 |
-				sched_type[2] << 8 |
-				queue_id[2];
-		sched_word[3] = EV_TO_DLB2_PRIO(ev[3].priority) << 10 |
-				sched_type[3] << 8 |
-				queue_id[3];
-
-		/* Store the event priority, scheduling type, and queue ID in
-		 * the metadata:
-		 * sse_qe[0][31:16] = sched_word[0]
-		 * sse_qe[0][95:80] = sched_word[1]
-		 * sse_qe[1][31:16] = sched_word[2]
-		 * sse_qe[1][95:80] = sched_word[3]
-		 */
-#define DLB2_QE_QID_SCHED_WORD 1
-		sse_qe[0] = _mm_insert_epi16(sse_qe[0],
-					     sched_word[0],
-					     DLB2_QE_QID_SCHED_WORD);
-		sse_qe[0] = _mm_insert_epi16(sse_qe[0],
-					     sched_word[1],
-					     DLB2_QE_QID_SCHED_WORD + 4);
-		sse_qe[1] = _mm_insert_epi16(sse_qe[1],
-					     sched_word[2],
-					     DLB2_QE_QID_SCHED_WORD);
-		sse_qe[1] = _mm_insert_epi16(sse_qe[1],
-					     sched_word[3],
-					     DLB2_QE_QID_SCHED_WORD + 4);
-
-		/* If the destination is a load-balanced queue, store the lock
-		 * ID. If it is a directed queue, DLB places this field in
-		 * bytes 10-11 of the received QE, so we format it accordingly:
-		 * sse_qe[0][47:32]  = dir queue ? sched_word[0] : flow_id[0]
-		 * sse_qe[0][111:96] = dir queue ? sched_word[1] : flow_id[1]
-		 * sse_qe[1][47:32]  = dir queue ? sched_word[2] : flow_id[2]
-		 * sse_qe[1][111:96] = dir queue ? sched_word[3] : flow_id[3]
-		 */
-#define DLB2_QE_LOCK_ID_WORD 2
-		sse_qe[0] = _mm_insert_epi16(sse_qe[0],
-				(sched_type[0] == DLB2_SCHED_DIRECTED) ?
-					sched_word[0] : ev[0].flow_id,
-				DLB2_QE_LOCK_ID_WORD);
-		sse_qe[0] = _mm_insert_epi16(sse_qe[0],
-				(sched_type[1] == DLB2_SCHED_DIRECTED) ?
-					sched_word[1] : ev[1].flow_id,
-				DLB2_QE_LOCK_ID_WORD + 4);
-		sse_qe[1] = _mm_insert_epi16(sse_qe[1],
-				(sched_type[2] == DLB2_SCHED_DIRECTED) ?
-					sched_word[2] : ev[2].flow_id,
-				DLB2_QE_LOCK_ID_WORD);
-		sse_qe[1] = _mm_insert_epi16(sse_qe[1],
-				(sched_type[3] == DLB2_SCHED_DIRECTED) ?
-					sched_word[3] : ev[3].flow_id,
-				DLB2_QE_LOCK_ID_WORD + 4);
-
-		/* Store the event type and sub event type in the metadata:
-		 * sse_qe[0][15:0]  = flow_id[0]
-		 * sse_qe[0][79:64] = flow_id[1]
-		 * sse_qe[1][15:0]  = flow_id[2]
-		 * sse_qe[1][79:64] = flow_id[3]
-		 */
-#define DLB2_QE_EV_TYPE_WORD 0
-		sse_qe[0] = _mm_insert_epi16(sse_qe[0],
-					     ev[0].sub_event_type << 8 |
-						ev[0].event_type,
-					     DLB2_QE_EV_TYPE_WORD);
-		sse_qe[0] = _mm_insert_epi16(sse_qe[0],
-					     ev[1].sub_event_type << 8 |
-						ev[1].event_type,
-					     DLB2_QE_EV_TYPE_WORD + 4);
-		sse_qe[1] = _mm_insert_epi16(sse_qe[1],
-					     ev[2].sub_event_type << 8 |
-						ev[2].event_type,
-					     DLB2_QE_EV_TYPE_WORD);
-		sse_qe[1] = _mm_insert_epi16(sse_qe[1],
-					     ev[3].sub_event_type << 8 |
-						ev[3].event_type,
-					     DLB2_QE_EV_TYPE_WORD + 4);
-
-		/* Store the metadata to memory (use the double-precision
-		 * _mm_storeh_pd because there is no integer function for
-		 * storing the upper 64b):
-		 * qe[0] metadata = sse_qe[0][63:0]
-		 * qe[1] metadata = sse_qe[0][127:64]
-		 * qe[2] metadata = sse_qe[1][63:0]
-		 * qe[3] metadata = sse_qe[1][127:64]
-		 */
-		_mm_storel_epi64((__m128i *)&qe[0].u.opaque_data, sse_qe[0]);
-		_mm_storeh_pd((double *)&qe[1].u.opaque_data,
-			      (__m128d)sse_qe[0]);
-		_mm_storel_epi64((__m128i *)&qe[2].u.opaque_data, sse_qe[1]);
-		_mm_storeh_pd((double *)&qe[3].u.opaque_data,
-			      (__m128d)sse_qe[1]);
-
-		qe[0].data = ev[0].u64;
-		qe[1].data = ev[1].u64;
-		qe[2].data = ev[2].u64;
-		qe[3].data = ev[3].u64;
-
-		break;
-	case 3:
-	case 2:
-	case 1:
-		for (i = 0; i < num; i++) {
-			qe[i].cmd_byte =
-				cmd_byte_map[qm_port->is_directed][ev[i].op];
-			qe[i].sched_type = sched_type[i];
-			qe[i].data = ev[i].u64;
-			qe[i].qid = queue_id[i];
-			qe[i].priority = EV_TO_DLB2_PRIO(ev[i].priority);
-			qe[i].lock_id = ev[i].flow_id;
-			if (sched_type[i] == DLB2_SCHED_DIRECTED) {
-				struct dlb2_msg_info *info =
-					(struct dlb2_msg_info *)&qe[i].lock_id;
-
-				info->qid = queue_id[i];
-				info->sched_type = DLB2_SCHED_DIRECTED;
-				info->priority = qe[i].priority;
-			}
-			qe[i].u.event_type.major = ev[i].event_type;
-			qe[i].u.event_type.sub = ev[i].sub_event_type;
-		}
-		break;
-	case 0:
-		break;
-	}
-}
-
 static inline int
 dlb2_event_enqueue_prep(struct dlb2_eventdev_port *ev_port,
 			struct dlb2_port *qm_port,
drivers/event/dlb2/dlb2_avx512.c new file +267 -0

267 lines not on this page · raw message

drivers/event/dlb2/dlb2_noavx512.c new file +219 -0

219 lines not on this page · raw message

drivers/event/dlb2/dlb2_priv.h +8 -0
index 3e47e4776b..b02d28467f 100644
@@ -377,6 +377,7 @@ struct dlb2_port {
 	struct dlb2_eventdev_port *ev_port; /* back ptr */
 	bool use_scalar; /* force usage of scalar code */
 	uint16_t hw_credit_quanta;
+	bool use_avx512;
 };
 
 /* Per-process per-port mmio and memory pointers */
@@ -685,6 +686,13 @@ int dlb2_parse_params(const char *params,
 		      struct dlb2_devargs *dlb2_args,
 		      uint8_t version);
 
+void dlb2_event_build_hcws(struct dlb2_port *qm_port,
+			   const struct rte_event ev[],
+			   int num,
+			   uint8_t *sched_type,
+			   uint8_t *queue_id);
+
+
 /* Extern globals */
 extern struct process_local_port_data dlb2_port[][DLB2_NUM_PORT_TYPES];
 
drivers/event/dlb2/meson.build +14 -0
index f963589fd3..efd93c7093 100644
@@ -19,6 +19,20 @@ sources = files(
         'dlb2_selftest.c',
 )
 
+dlb2_avx512_support = false
+
+if dpdk_conf.has('RTE_ARCH_X86_64')
+        dlb2_avx512_support = (
+	    cc.get_define('__AVX512VL__', args: machine_args) != ''
+	)
+endif
+
+if dlb2_avx512_support == true
+        sources += files('dlb2_avx512.c')
+else
+        sources += files('dlb2_noavx512.c')
+endif
+
 headers = files('rte_pmd_dlb2.h')
 
 deps += ['mbuf', 'mempool', 'ring', 'pci', 'bus_pci']
Signature · 1 line
2.25.1
#5 lore raw

PATCH v4 1/1 event/dlb2: add support for single 512B write of 4 QEs

In reply to Timothy McDaniel

On Xeon, as 512b accesses are available, movdir64 instruction is able to perform 512b read and write to DLB producer port. In order for movdir64 to be able to pull its data from store buffers (store-buffer-forwarding) (before actual write), data should be in single 512b write format. This commit add change when code is built for Xeon with 512b AVX support to make single 512b write of all 4 QEs instead of 4x64b writes.

===

Changes since V3:
1) Renamed dlb2_noavx512.c to dlb2_sve.c, and fixed up meson.build for new file name.

Changes since V1:
1) Split out dlb2_event_build_hcws into two implementations, one that uses AVX512 instructions, and one that does not. Each implementation is in its own source file in order to avoid build errors if the compiler does not support the newer AVX512 instructions.
2) Update meson.build to and pull in appropriate source file based on whether the compiler supports AVX512VL
3) Check if target supports AVX512VL, and use appropriate implementation based on this runtime check.

---
 drivers/event/dlb2/dlb2.c        | 206 +-----------------------
 drivers/event/dlb2/dlb2_avx512.c | 267 +++++++++++++++++++++++++++++++
 drivers/event/dlb2/dlb2_priv.h   |   8 +
 drivers/event/dlb2/dlb2_sve.c    | 219 +++++++++++++++++++++++++
 drivers/event/dlb2/meson.build   |  14 ++
 5 files changed, 513 insertions(+), 201 deletions(-)
 create mode 100644 drivers/event/dlb2/dlb2_avx512.c
 create mode 100644 drivers/event/dlb2/dlb2_sve.c
drivers/event/dlb2/dlb2.c +5 -201
index 36f07d0061..ac7572a28d 100644
@@ -1834,6 +1834,11 @@ dlb2_eventdev_port_setup(struct rte_eventdev *dev,
 
 	dev->data->ports[ev_port_id] = &dlb2->ev_ports[ev_port_id];
 
+	if (rte_cpu_get_flag_enabled(RTE_CPUFLAG_AVX512VL))
+		ev_port->qm_port.use_avx512 = true;
+	else
+		ev_port->qm_port.use_avx512 = false;
+
 	return 0;
 }
 
@@ -2430,21 +2435,6 @@ dlb2_eventdev_start(struct rte_eventdev *dev)
 	return 0;
 }
 
-static uint8_t cmd_byte_map[DLB2_NUM_PORT_TYPES][DLB2_NUM_HW_SCHED_TYPES] = {
-	{
-		/* Load-balanced cmd bytes */
-		[RTE_EVENT_OP_NEW] = DLB2_NEW_CMD_BYTE,
-		[RTE_EVENT_OP_FORWARD] = DLB2_FWD_CMD_BYTE,
-		[RTE_EVENT_OP_RELEASE] = DLB2_COMP_CMD_BYTE,
-	},
-	{
-		/* Directed cmd bytes */
-		[RTE_EVENT_OP_NEW] = DLB2_NEW_CMD_BYTE,
-		[RTE_EVENT_OP_FORWARD] = DLB2_NEW_CMD_BYTE,
-		[RTE_EVENT_OP_RELEASE] = DLB2_NOOP_CMD_BYTE,
-	},
-};
-
 static inline uint32_t
 dlb2_port_credits_get(struct dlb2_port *qm_port,
 		      enum dlb2_hw_queue_types type)
@@ -2639,192 +2629,6 @@ dlb2_construct_token_pop_qe(struct dlb2_port *qm_port, int idx)
 	qm_port->owed_tokens = 0;
 }
 
-static inline void
-dlb2_event_build_hcws(struct dlb2_port *qm_port,
-		      const struct rte_event ev[],
-		      int num,
-		      uint8_t *sched_type,
-		      uint8_t *queue_id)
-{
-	struct dlb2_enqueue_qe *qe;
-	uint16_t sched_word[4];
-	__m128i sse_qe[2];
-	int i;
-
-	qe = qm_port->qe4;
-
-	sse_qe[0] = _mm_setzero_si128();
-	sse_qe[1] = _mm_setzero_si128();
-
-	switch (num) {
-	case 4:
-		/* Construct the metadata portion of two HCWs in one 128b SSE
-		 * register. HCW metadata is constructed in the SSE registers
-		 * like so:
-		 * sse_qe[0][63:0]:   qe[0]'s metadata
-		 * sse_qe[0][127:64]: qe[1]'s metadata
-		 * sse_qe[1][63:0]:   qe[2]'s metadata
-		 * sse_qe[1][127:64]: qe[3]'s metadata
-		 */
-
-		/* Convert the event operation into a command byte and store it
-		 * in the metadata:
-		 * sse_qe[0][63:56]   = cmd_byte_map[is_directed][ev[0].op]
-		 * sse_qe[0][127:120] = cmd_byte_map[is_directed][ev[1].op]
-		 * sse_qe[1][63:56]   = cmd_byte_map[is_directed][ev[2].op]
-		 * sse_qe[1][127:120] = cmd_byte_map[is_directed][ev[3].op]
-		 */
-#define DLB2_QE_CMD_BYTE 7
-		sse_qe[0] = _mm_insert_epi8(sse_qe[0],
-				cmd_byte_map[qm_port->is_directed][ev[0].op],
-				DLB2_QE_CMD_BYTE);
-		sse_qe[0] = _mm_insert_epi8(sse_qe[0],
-				cmd_byte_map[qm_port->is_directed][ev[1].op],
-				DLB2_QE_CMD_BYTE + 8);
-		sse_qe[1] = _mm_insert_epi8(sse_qe[1],
-				cmd_byte_map[qm_port->is_directed][ev[2].op],
-				DLB2_QE_CMD_BYTE);
-		sse_qe[1] = _mm_insert_epi8(sse_qe[1],
-				cmd_byte_map[qm_port->is_directed][ev[3].op],
-				DLB2_QE_CMD_BYTE + 8);
-
-		/* Store priority, scheduling type, and queue ID in the sched
-		 * word array because these values are re-used when the
-		 * destination is a directed queue.
-		 */
-		sched_word[0] = EV_TO_DLB2_PRIO(ev[0].priority) << 10 |
-				sched_type[0] << 8 |
-				queue_id[0];
-		sched_word[1] = EV_TO_DLB2_PRIO(ev[1].priority) << 10 |
-				sched_type[1] << 8 |
-				queue_id[1];
-		sched_word[2] = EV_TO_DLB2_PRIO(ev[2].priority) << 10 |
-				sched_type[2] << 8 |
-				queue_id[2];
-		sched_word[3] = EV_TO_DLB2_PRIO(ev[3].priority) << 10 |
-				sched_type[3] << 8 |
-				queue_id[3];
-
-		/* Store the event priority, scheduling type, and queue ID in
-		 * the metadata:
-		 * sse_qe[0][31:16] = sched_word[0]
-		 * sse_qe[0][95:80] = sched_word[1]
-		 * sse_qe[1][31:16] = sched_word[2]
-		 * sse_qe[1][95:80] = sched_word[3]
-		 */
-#define DLB2_QE_QID_SCHED_WORD 1
-		sse_qe[0] = _mm_insert_epi16(sse_qe[0],
-					     sched_word[0],
-					     DLB2_QE_QID_SCHED_WORD);
-		sse_qe[0] = _mm_insert_epi16(sse_qe[0],
-					     sched_word[1],
-					     DLB2_QE_QID_SCHED_WORD + 4);
-		sse_qe[1] = _mm_insert_epi16(sse_qe[1],
-					     sched_word[2],
-					     DLB2_QE_QID_SCHED_WORD);
-		sse_qe[1] = _mm_insert_epi16(sse_qe[1],
-					     sched_word[3],
-					     DLB2_QE_QID_SCHED_WORD + 4);
-
-		/* If the destination is a load-balanced queue, store the lock
-		 * ID. If it is a directed queue, DLB places this field in
-		 * bytes 10-11 of the received QE, so we format it accordingly:
-		 * sse_qe[0][47:32]  = dir queue ? sched_word[0] : flow_id[0]
-		 * sse_qe[0][111:96] = dir queue ? sched_word[1] : flow_id[1]
-		 * sse_qe[1][47:32]  = dir queue ? sched_word[2] : flow_id[2]
-		 * sse_qe[1][111:96] = dir queue ? sched_word[3] : flow_id[3]
-		 */
-#define DLB2_QE_LOCK_ID_WORD 2
-		sse_qe[0] = _mm_insert_epi16(sse_qe[0],
-				(sched_type[0] == DLB2_SCHED_DIRECTED) ?
-					sched_word[0] : ev[0].flow_id,
-				DLB2_QE_LOCK_ID_WORD);
-		sse_qe[0] = _mm_insert_epi16(sse_qe[0],
-				(sched_type[1] == DLB2_SCHED_DIRECTED) ?
-					sched_word[1] : ev[1].flow_id,
-				DLB2_QE_LOCK_ID_WORD + 4);
-		sse_qe[1] = _mm_insert_epi16(sse_qe[1],
-				(sched_type[2] == DLB2_SCHED_DIRECTED) ?
-					sched_word[2] : ev[2].flow_id,
-				DLB2_QE_LOCK_ID_WORD);
-		sse_qe[1] = _mm_insert_epi16(sse_qe[1],
-				(sched_type[3] == DLB2_SCHED_DIRECTED) ?
-					sched_word[3] : ev[3].flow_id,
-				DLB2_QE_LOCK_ID_WORD + 4);
-
-		/* Store the event type and sub event type in the metadata:
-		 * sse_qe[0][15:0]  = flow_id[0]
-		 * sse_qe[0][79:64] = flow_id[1]
-		 * sse_qe[1][15:0]  = flow_id[2]
-		 * sse_qe[1][79:64] = flow_id[3]
-		 */
-#define DLB2_QE_EV_TYPE_WORD 0
-		sse_qe[0] = _mm_insert_epi16(sse_qe[0],
-					     ev[0].sub_event_type << 8 |
-						ev[0].event_type,
-					     DLB2_QE_EV_TYPE_WORD);
-		sse_qe[0] = _mm_insert_epi16(sse_qe[0],
-					     ev[1].sub_event_type << 8 |
-						ev[1].event_type,
-					     DLB2_QE_EV_TYPE_WORD + 4);
-		sse_qe[1] = _mm_insert_epi16(sse_qe[1],
-					     ev[2].sub_event_type << 8 |
-						ev[2].event_type,
-					     DLB2_QE_EV_TYPE_WORD);
-		sse_qe[1] = _mm_insert_epi16(sse_qe[1],
-					     ev[3].sub_event_type << 8 |
-						ev[3].event_type,
-					     DLB2_QE_EV_TYPE_WORD + 4);
-
-		/* Store the metadata to memory (use the double-precision
-		 * _mm_storeh_pd because there is no integer function for
-		 * storing the upper 64b):
-		 * qe[0] metadata = sse_qe[0][63:0]
-		 * qe[1] metadata = sse_qe[0][127:64]
-		 * qe[2] metadata = sse_qe[1][63:0]
-		 * qe[3] metadata = sse_qe[1][127:64]
-		 */
-		_mm_storel_epi64((__m128i *)&qe[0].u.opaque_data, sse_qe[0]);
-		_mm_storeh_pd((double *)&qe[1].u.opaque_data,
-			      (__m128d)sse_qe[0]);
-		_mm_storel_epi64((__m128i *)&qe[2].u.opaque_data, sse_qe[1]);
-		_mm_storeh_pd((double *)&qe[3].u.opaque_data,
-			      (__m128d)sse_qe[1]);
-
-		qe[0].data = ev[0].u64;
-		qe[1].data = ev[1].u64;
-		qe[2].data = ev[2].u64;
-		qe[3].data = ev[3].u64;
-
-		break;
-	case 3:
-	case 2:
-	case 1:
-		for (i = 0; i < num; i++) {
-			qe[i].cmd_byte =
-				cmd_byte_map[qm_port->is_directed][ev[i].op];
-			qe[i].sched_type = sched_type[i];
-			qe[i].data = ev[i].u64;
-			qe[i].qid = queue_id[i];
-			qe[i].priority = EV_TO_DLB2_PRIO(ev[i].priority);
-			qe[i].lock_id = ev[i].flow_id;
-			if (sched_type[i] == DLB2_SCHED_DIRECTED) {
-				struct dlb2_msg_info *info =
-					(struct dlb2_msg_info *)&qe[i].lock_id;
-
-				info->qid = queue_id[i];
-				info->sched_type = DLB2_SCHED_DIRECTED;
-				info->priority = qe[i].priority;
-			}
-			qe[i].u.event_type.major = ev[i].event_type;
-			qe[i].u.event_type.sub = ev[i].sub_event_type;
-		}
-		break;
-	case 0:
-		break;
-	}
-}
-
 static inline int
 dlb2_event_enqueue_prep(struct dlb2_eventdev_port *ev_port,
 			struct dlb2_port *qm_port,
drivers/event/dlb2/dlb2_avx512.c new file +267 -0

267 lines not on this page · raw message

drivers/event/dlb2/dlb2_priv.h +8 -0
index 3e47e4776b..b02d28467f 100644
@@ -377,6 +377,7 @@ struct dlb2_port {
 	struct dlb2_eventdev_port *ev_port; /* back ptr */
 	bool use_scalar; /* force usage of scalar code */
 	uint16_t hw_credit_quanta;
+	bool use_avx512;
 };
 
 /* Per-process per-port mmio and memory pointers */
@@ -685,6 +686,13 @@ int dlb2_parse_params(const char *params,
 		      struct dlb2_devargs *dlb2_args,
 		      uint8_t version);
 
+void dlb2_event_build_hcws(struct dlb2_port *qm_port,
+			   const struct rte_event ev[],
+			   int num,
+			   uint8_t *sched_type,
+			   uint8_t *queue_id);
+
+
 /* Extern globals */
 extern struct process_local_port_data dlb2_port[][DLB2_NUM_PORT_TYPES];
 
drivers/event/dlb2/dlb2_sve.c new file +219 -0

219 lines not on this page · raw message

drivers/event/dlb2/meson.build +14 -0
index f963589fd3..0ad4d31785 100644
@@ -19,6 +19,20 @@ sources = files(
         'dlb2_selftest.c',
 )
 
+dlb2_avx512_support = false
+
+if dpdk_conf.has('RTE_ARCH_X86_64')
+        dlb2_avx512_support = (
+	    cc.get_define('__AVX512VL__', args: machine_args) != ''
+	)
+endif
+
+if dlb2_avx512_support == true
+        sources += files('dlb2_avx512.c')
+else
+        sources += files('dlb2_sve.c')
+endif
+
 headers = files('rte_pmd_dlb2.h')
 
 deps += ['mbuf', 'mempool', 'ring', 'pci', 'bus_pci']
Signature · 1 line
2.25.1
#6 lore raw
Quoted 34 lines · Timothy McDaniel

On Xeon, as 512b accesses are available, movdir64 instruction is able to perform 512b read and write to DLB producer port. In order for movdir64 to be able to pull its data from store buffers (store-buffer-forwarding) (before actual write), data should be in single 512b write format. This commit add change when code is built for Xeon with 512b AVX support to make single 512b write of all 4 QEs instead of 4x64b writes.

===

Changes since V3:
1) Renamed dlb2_noavx512.c to dlb2_sve.c, and fixed up meson.build for new file name.

Changes since V1:
1) Split out dlb2_event_build_hcws into two implementations, one that uses AVX512 instructions, and one that does not. Each implementation is in its own source file in order to avoid build errors if the compiler does not support the newer AVX512 instructions.
2) Update meson.build to and pull in appropriate source file based on whether the compiler supports AVX512VL
3) Check if target supports AVX512VL, and use appropriate implementation based on this runtime check.

---
 drivers/event/dlb2/dlb2.c        | 206 +-----------------------
 drivers/event/dlb2/dlb2_avx512.c | 267 +++++++++++++++++++++++++++++++
 drivers/event/dlb2/dlb2_priv.h   |   8 +
 drivers/event/dlb2/dlb2_sve.c    | 219 +++++++++++++++++++++++++
 drivers/event/dlb2/meson.build   |  14 ++
 5 files changed, 513 insertions(+), 201 deletions(-)
 create mode 100644 drivers/event/dlb2/dlb2_avx512.c
 create mode 100644 drivers/event/dlb2/dlb2_sve.c

<snip>

Quoted 15 lines
drivers/event/dlb2/meson.build +7 -0
index f963589fd3..0ad4d31785 100644
@@ -19,6 +19,20 @@ sources = files(
         'dlb2_selftest.c',
 )
 
+dlb2_avx512_support = false
+
+if dpdk_conf.has('RTE_ARCH_X86_64')
+        dlb2_avx512_support = (
+	    cc.get_define('__AVX512VL__', args: machine_args) != ''
+	)
+endif

drivers/event/dlb2/meson.build sources = files( · line 38

Quoted 10 lines
drivers/event/dlb2/meson.build +7 -0
+
+if dlb2_avx512_support == true
+        sources += files('dlb2_avx512.c')
+else
+        sources += files('dlb2_sve.c')
+endif
+
 headers = files('rte_pmd_dlb2.h')
 
 deps += ['mbuf', 'mempool', 'ring', 'pci', 'bus_pci']

I believe this can be improved upon further, since it still does not allow a generic build to opportunistically use the AVX-512 code path. It also makes the runtime check largely pointless as the whole build will have been done with global AVX-512 support, meaning that the binary likely will fail to run if AVX-512 is not available.

Instead, I'd recommend doing as other places in DPDK - such as in ACL library, or i40e or ice net drivers - where we not only check the current build support, but also check the compiler support. That way, even if we are building for e.g. a target of AVX2, we can still build the AVX-512 parts using the appropriate compiler flags, and choose them opportunistically at runtime. See the meson.build files in any of the above component directories for examples.

Regards,

/Bruce

#11 lore raw
In reply to Timothy McDaniel
Quoted 40 lines · Timothy McDaniel

On Xeon, as 512b accesses are available, movdir64 instruction is able to perform 512b read and write to DLB producer port. In order for movdir64 to be able to pull its data from store buffers (store-buffer-forwarding) (before actual write), data should be in single 512b write format. This commit add change when code is built for Xeon with 512b AVX support to make single 512b write of all 4 QEs instead of 4x64b writes.

===

Changes since V3:
1) Renamed dlb2_noavx512.c to dlb2_sve.c, and fixed up meson.build for new file name.

Changes since V1:
1) Split out dlb2_event_build_hcws into two implementations, one that uses AVX512 instructions, and one that does not. Each implementation is in its own source file in order to avoid build errors if the compiler does not support the newer AVX512 instructions.
2) Update meson.build to and pull in appropriate source file based on whether the compiler supports AVX512VL
3) Check if target supports AVX512VL, and use appropriate implementation based on this runtime check.

---
 drivers/event/dlb2/dlb2.c        | 206 +-----------------------
 drivers/event/dlb2/dlb2_avx512.c | 267 +++++++++++++++++++++++++++++++
 drivers/event/dlb2/dlb2_priv.h   |   8 +
 drivers/event/dlb2/dlb2_sve.c    | 219 +++++++++++++++++++++++++
 drivers/event/dlb2/meson.build   |  14 ++
 5 files changed, 513 insertions(+), 201 deletions(-)
 create mode 100644 drivers/event/dlb2/dlb2_avx512.c
 create mode 100644 drivers/event/dlb2/dlb2_sve.c
drivers/event/dlb2/dlb2.c +0 -0
index 36f07d0061..ac7572a28d 100644
@@ -1834,6 +1834,11 @@ dlb2_eventdev_port_setup(struct rte_eventdev *dev,
 

drivers/event/dlb2/dlb2.c dlb2_eventdev_port_setup(struct rte_eventdev *dev, · line 1844

Quoted 10 lines
drivers/event/dlb2/dlb2.c +5 -0
 	dev->data->ports[ev_port_id] = &dlb2->ev_ports[ev_port_id];
 
+	if (rte_cpu_get_flag_enabled(RTE_CPUFLAG_AVX512VL))
+		ev_port->qm_port.use_avx512 = true;
+	else
+		ev_port->qm_port.use_avx512 = false;
+
 	return 0;
 }
 

Additional comment for this runtime check. You also should check the max_simd_bitwidth in DPDK i.e. the value specified with --force-max-simd-bitwidth EAL argument, or set programmatically by the app. This is to allow the user runtime control over when the various instruction sets get used, and it's also very useful for testing and debugging various code paths.

/Bruce

#12 lore raw

Sorry Bruce, but I don't have a clue what you are talking about here.

Quoted 69 lines

-----Original Message-----
From: Richardson, Bruce <[email protected]>
Sent: Monday, May 23, 2022 11:37 AM
To: McDaniel, Timothy <[email protected]>
Cc: [email protected]; [email protected]; Wires, Kent <[email protected]>
Subject: Re: [PATCH v4] event/dlb2: add support for single 512B write of 4 QEs

Quoted 24 lines · Timothy McDaniel

On Xeon, as 512b accesses are available, movdir64 instruction is able to perform 512b read and write to DLB producer port. In order for movdir64 to be able to pull its data from store buffers (store-buffer-forwarding) (before actual write), data should be in single 512b write format. This commit add change when code is built for Xeon with 512b AVX support to make single 512b write of all 4 QEs instead of 4x64b writes.

===

Changes since V3:
1) Renamed dlb2_noavx512.c to dlb2_sve.c, and fixed up meson.build for new file name.

Changes since V1:
1) Split out dlb2_event_build_hcws into two implementations, one that uses AVX512 instructions, and one that does not. Each implementation is in its own source file in order to avoid build errors if the compiler does not support the newer AVX512 instructions.
2) Update meson.build to and pull in appropriate source file based on whether the compiler supports AVX512VL
3) Check if target supports AVX512VL, and use appropriate implementation based on this runtime check.

Quoted 3 lines
---
 drivers/event/dlb2/dlb2.c        | 206 +-----------------------
 drivers/event/dlb2/dlb2_avx512.c | 267

+++++++++++++++++++++++++++++++

drivers/event/dlb2/dlb2.c dlb2_eventdev_port_setup(struct rte_eventdev

Quoted 12 lines
 drivers/event/dlb2/dlb2_priv.h   |   8 +
 drivers/event/dlb2/dlb2_sve.c    | 219 +++++++++++++++++++++++++
 drivers/event/dlb2/meson.build   |  14 ++
 5 files changed, 513 insertions(+), 201 deletions(-)
 create mode 100644 drivers/event/dlb2/dlb2_avx512.c
 create mode 100644 drivers/event/dlb2/dlb2_sve.c
drivers/event/dlb2/dlb2.c +0 -0
index 36f07d0061..ac7572a28d 100644
@@ -1834,6 +1834,11 @@ dlb2_eventdev_port_setup(struct rte_eventdev

*dev,

drivers/event/dlb2/dlb2.c dlb2_eventdev_port_setup(struct rte_eventdev *dev, · line 1844

Quoted 11 lines
drivers/event/dlb2/dlb2.c +5 -0
 	dev->data->ports[ev_port_id] = &dlb2->ev_ports[ev_port_id];
 
+	if (rte_cpu_get_flag_enabled(RTE_CPUFLAG_AVX512VL))
+		ev_port->qm_port.use_avx512 = true;
+	else
+		ev_port->qm_port.use_avx512 = false;
+
 	return 0;
 }
 

Additional comment for this runtime check. You also should check the max_simd_bitwidth in DPDK i.e. the value specified with --force-max-simd-bitwidth EAL argument, or set programmatically by the app. This is to allow the user runtime control over when the various instruction sets get used, and it's also very useful for testing and debugging various code paths.

/Bruce

#7 lore raw
In reply to Bruce Richardson
Quoted 70 lines

-----Original Message-----
From: Richardson, Bruce <[email protected]>
Sent: Monday, May 23, 2022 11:34 AM
To: McDaniel, Timothy <[email protected]>
Cc: [email protected]; [email protected]; Wires, Kent <[email protected]>
Subject: Re: [PATCH v4] event/dlb2: add support for single 512B write of 4 QEs

Quoted 24 lines · Timothy McDaniel

On Xeon, as 512b accesses are available, movdir64 instruction is able to perform 512b read and write to DLB producer port. In order for movdir64 to be able to pull its data from store buffers (store-buffer-forwarding) (before actual write), data should be in single 512b write format. This commit add change when code is built for Xeon with 512b AVX support to make single 512b write of all 4 QEs instead of 4x64b writes.

===

Changes since V3:
1) Renamed dlb2_noavx512.c to dlb2_sve.c, and fixed up meson.build for new file name.

Changes since V1:
1) Split out dlb2_event_build_hcws into two implementations, one that uses AVX512 instructions, and one that does not. Each implementation is in its own source file in order to avoid build errors if the compiler does not support the newer AVX512 instructions.
2) Update meson.build to and pull in appropriate source file based on whether the compiler supports AVX512VL
3) Check if target supports AVX512VL, and use appropriate implementation based on this runtime check.

Quoted 3 lines
---
 drivers/event/dlb2/dlb2.c        | 206 +-----------------------
 drivers/event/dlb2/dlb2_avx512.c | 267

+++++++++++++++++++++++++++++++

Quoted 7 lines
 drivers/event/dlb2/dlb2_priv.h   |   8 +
 drivers/event/dlb2/dlb2_sve.c    | 219 +++++++++++++++++++++++++
 drivers/event/dlb2/meson.build   |  14 ++
 5 files changed, 513 insertions(+), 201 deletions(-)
 create mode 100644 drivers/event/dlb2/dlb2_avx512.c
 create mode 100644 drivers/event/dlb2/dlb2_sve.c

<snip>

Quoted 24 lines
drivers/event/dlb2/meson.build +14 -0
index f963589fd3..0ad4d31785 100644
@@ -19,6 +19,20 @@ sources = files(
         'dlb2_selftest.c',
 )
 
+dlb2_avx512_support = false
+
+if dpdk_conf.has('RTE_ARCH_X86_64')
+        dlb2_avx512_support = (
+	    cc.get_define('__AVX512VL__', args: machine_args) != ''
+	)
+endif
+
+if dlb2_avx512_support == true
+        sources += files('dlb2_avx512.c')
+else
+        sources += files('dlb2_sve.c')
+endif
+
 headers = files('rte_pmd_dlb2.h')
 
Quoted 4 lines

drivers/event/dlb2/meson.build sources = files( · line 38

Quoted 1 line
drivers/event/dlb2/meson.build +0 -0
 deps += ['mbuf', 'mempool', 'ring', 'pci', 'bus_pci']

I believe this can be improved upon further, since it still does not allow a generic build to opportunistically use the AVX-512 code path.

What does this mean - " generic build to opportunistically use the AVX-512 code path"

It also

Quoted 3 lines

makes the runtime check largely pointless as the whole build will have been done with global AVX-512 support, meaning that the binary likely will fail to run if AVX-512 is not available.

If built for avx512, then that build supports using either avx512, or not.

Quoted 7 lines

Instead, I'd recommend doing as other places in DPDK - such as in ACL library, or i40e or ice net drivers - where we not only check the current build support, but also check the compiler support. That way, even if we are building for e.g. a target of AVX2, we can still build the AVX-512 parts using the appropriate compiler flags, and choose them opportunistically at runtime.

I do not understand what you are getting at here.

See the meson.build files in any of the above

Quoted 5 lines

component directories for examples.

Regards,

/Bruce

#8 lore raw
Quoted 75 lines · Timothy
Quoted 70 lines

-----Original Message-----
From: Richardson, Bruce <[email protected]>
Sent: Monday, May 23, 2022 11:34 AM
To: McDaniel, Timothy <[email protected]>
Cc: [email protected]; [email protected]; Wires, Kent <[email protected]>
Subject: Re: [PATCH v4] event/dlb2: add support for single 512B write of 4 QEs

Quoted 24 lines · Timothy McDaniel

On Xeon, as 512b accesses are available, movdir64 instruction is able to perform 512b read and write to DLB producer port. In order for movdir64 to be able to pull its data from store buffers (store-buffer-forwarding) (before actual write), data should be in single 512b write format. This commit add change when code is built for Xeon with 512b AVX support to make single 512b write of all 4 QEs instead of 4x64b writes.

===

Changes since V3:
1) Renamed dlb2_noavx512.c to dlb2_sve.c, and fixed up meson.build for new file name.

Changes since V1:
1) Split out dlb2_event_build_hcws into two implementations, one that uses AVX512 instructions, and one that does not. Each implementation is in its own source file in order to avoid build errors if the compiler does not support the newer AVX512 instructions.
2) Update meson.build to and pull in appropriate source file based on whether the compiler supports AVX512VL
3) Check if target supports AVX512VL, and use appropriate implementation based on this runtime check.

Quoted 3 lines
---
 drivers/event/dlb2/dlb2.c        | 206 +-----------------------
 drivers/event/dlb2/dlb2_avx512.c | 267

+++++++++++++++++++++++++++++++

Quoted 7 lines
 drivers/event/dlb2/dlb2_priv.h   |   8 +
 drivers/event/dlb2/dlb2_sve.c    | 219 +++++++++++++++++++++++++
 drivers/event/dlb2/meson.build   |  14 ++
 5 files changed, 513 insertions(+), 201 deletions(-)
 create mode 100644 drivers/event/dlb2/dlb2_avx512.c
 create mode 100644 drivers/event/dlb2/dlb2_sve.c

<snip>

Quoted 24 lines
drivers/event/dlb2/meson.build +14 -0
index f963589fd3..0ad4d31785 100644
@@ -19,6 +19,20 @@ sources = files(
         'dlb2_selftest.c',
 )
 
+dlb2_avx512_support = false
+
+if dpdk_conf.has('RTE_ARCH_X86_64')
+        dlb2_avx512_support = (
+       cc.get_define('__AVX512VL__', args: machine_args) != ''
+   )
+endif
+
+if dlb2_avx512_support == true
+        sources += files('dlb2_avx512.c')
+else
+        sources += files('dlb2_sve.c')
+endif
+
 headers = files('rte_pmd_dlb2.h')
 
Quoted 4 lines

drivers/event/dlb2/meson.build sources = files( · line 38

Quoted 1 line
drivers/event/dlb2/meson.build +0 -0
 deps += ['mbuf', 'mempool', 'ring', 'pci', 'bus_pci']

I believe this can be improved upon further, since it still does not allow a generic build to opportunistically use the AVX-512 code path.

Quoted 9 lines

What does this mean - " generic build to opportunistically use the AVX-512 code path"

It also

Quoted 3 lines

makes the runtime check largely pointless as the whole build will have been done with global AVX-512 support, meaning that the binary likely will fail to run if AVX-512 is not available.

If built for avx512, then that build supports using either avx512, or not.

No, if build for AVX-512, then the compiler can use AVX-512 instructions anywhere in the binary, so that build can only run on AVX-512 supporting systems.

Quoted 10 lines
Quoted 7 lines

Instead, I'd recommend doing as other places in DPDK - such as in ACL library, or i40e or ice net drivers - where we not only check the current build support, but also check the compiler support. That way, even if we are building for e.g. a target of AVX2, we can still build the AVX-512 parts using the appropriate compiler flags, and choose them opportunistically at runtime.

I do not understand what you are getting at here.

Check out net/i40e/meson.build and hopefully things may become clearer.

/Bruce

#9 lore raw
Quoted 13 lines · Bruce Richardson
Quoted 11 lines · Timothy
Quoted 10 lines

Instead, I'd recommend doing as other places in DPDK - such as in ACL library, or i40e or ice net drivers - where we not only check the current build support, but also check the compiler support. That way, even if we are building for e.g. a target of AVX2, we can still build the AVX-512 parts using the appropriate compiler flags, and choose them opportunistically at runtime.

Quoted 3 lines
Quoted 2 lines

I do not understand what you are getting at here.

Check out net/i40e/meson.build and hopefully things may become clearer.

I am updating the patchwork status as "Changes requested" for this patch.

@McDaniel, Timothy Please send the updated version. Also, the following patch depends on this. I will wait for the merging below after this patch is merged.

https://patches.dpdk.org/project/dpdk/patch/[email protected]/
https://patches.dpdk.org/project/dpdk/patch/[email protected]/

Quoted 2 lines

/Bruce

#10 lore raw

I will submit the changes requested by Bruce.

Thanks,
Tim

Quoted 41 lines

-----Original Message-----
From: Jerin Jacob <[email protected]>
Sent: Thursday, June 9, 2022 12:40 PM
To: Richardson, Bruce <[email protected]>
Cc: McDaniel, Timothy <[email protected]>; [email protected]; [email protected]; Wires, Kent <[email protected]>
Subject: Re: [PATCH v4] event/dlb2: add support for single 512B write of 4 QEs

Quoted 13 lines · Bruce Richardson
Quoted 11 lines · Timothy
Quoted 10 lines

Instead, I'd recommend doing as other places in DPDK - such as in ACL library, or i40e or ice net drivers - where we not only check the current build support, but also check the compiler support. That way, even if we are building for e.g. a target of AVX2, we can still build the AVX-512 parts using the appropriate compiler flags, and choose them opportunistically at runtime.

Quoted 3 lines
Quoted 2 lines

I do not understand what you are getting at here.

Check out net/i40e/meson.build and hopefully things may become clearer.

I am updating the patchwork status as "Changes requested" for this patch.

@McDaniel, Timothy Please send the updated version. Also, the following patch depends on this. I will wait for the merging below after this patch is merged.

https://patches.dpdk.org/project/dpdk/patch/20220410225602.1524724-1-
[email protected]/
https://patches.dpdk.org/project/dpdk/patch/20220410224755.1524117-1-
[email protected]/

Quoted 2 lines

/Bruce

#13 lore raw

PATCH v6 1/1 event/dlb2: add support for single 512B write of 4 QEs

In reply to Timothy McDaniel

On Xeon, 512b accesses are available, so movdir64 instruction is able to perform 512b read and write to DLB producer port. In order for movdir64 to be able to pull its data from store buffers (store-buffer-forwarding) (before actual write), data should be in single 512b write format. This commit add change when code is built for Xeon with 512b AVX support to make single 512b write of all 4 QEs instead of 4x64b writes.

===

Changes since V5:
No code changes - just added --in-reply-to and copied Bruce

Changes since V4:
1) Add build-time control for avx512 support to meson.buildi, based on implementation found in lib/acl/meson.build
2) Add rte_vect_get_max_simd_bitwidth runtime check before using avx512 instructions

Changes since V3:
1) Renamed dlb2_noavx512.c to dlb2_sve.c, and fixed up meson.build for new file name.

Changes since V1:
1) Split out dlb2_event_build_hcws into two implementations, one that uses AVX512 instructions, and one that does not. Each implementation is in its own source file in order to avoid build errors if the compiler does not support the newer AVX512 instructions.
2) Update meson.build to and pull in appropriate source file based on whether the compiler supports AVX512VL
3) Check if target supports AVX512VL, and use appropriate implementation based on this runtime check.

---
 drivers/event/dlb2/dlb2.c        | 208 +-----------------------
 drivers/event/dlb2/dlb2_avx512.c | 267 +++++++++++++++++++++++++++++++
 drivers/event/dlb2/dlb2_priv.h   |  10 ++
 drivers/event/dlb2/dlb2_sve.c    | 219 +++++++++++++++++++++++++
 drivers/event/dlb2/meson.build   |  53 ++++++
 5 files changed, 556 insertions(+), 201 deletions(-)
 create mode 100644 drivers/event/dlb2/dlb2_avx512.c
 create mode 100644 drivers/event/dlb2/dlb2_sve.c
drivers/event/dlb2/dlb2.c +7 -201
index 3641ed2942..0b70dc0f51 100644
@@ -1861,6 +1861,13 @@ dlb2_eventdev_port_setup(struct rte_eventdev *dev,
 
 	dev->data->ports[ev_port_id] = &dlb2->ev_ports[ev_port_id];
 
+#ifdef CC_AVX512_SUPPORT
+	if (rte_cpu_get_flag_enabled(RTE_CPUFLAG_AVX512VL) &&
+	    rte_vect_get_max_simd_bitwidth() >= RTE_VECT_SIMD_512)
+		ev_port->qm_port.use_avx512 = true;
+	else
+		ev_port->qm_port.use_avx512 = false;
+#endif
 	return 0;
 }
 
@@ -2457,21 +2464,6 @@ dlb2_eventdev_start(struct rte_eventdev *dev)
 	return 0;
 }
 
-static uint8_t cmd_byte_map[DLB2_NUM_PORT_TYPES][DLB2_NUM_HW_SCHED_TYPES] = {
-	{
-		/* Load-balanced cmd bytes */
-		[RTE_EVENT_OP_NEW] = DLB2_NEW_CMD_BYTE,
-		[RTE_EVENT_OP_FORWARD] = DLB2_FWD_CMD_BYTE,
-		[RTE_EVENT_OP_RELEASE] = DLB2_COMP_CMD_BYTE,
-	},
-	{
-		/* Directed cmd bytes */
-		[RTE_EVENT_OP_NEW] = DLB2_NEW_CMD_BYTE,
-		[RTE_EVENT_OP_FORWARD] = DLB2_NEW_CMD_BYTE,
-		[RTE_EVENT_OP_RELEASE] = DLB2_NOOP_CMD_BYTE,
-	},
-};
-
 static inline uint32_t
 dlb2_port_credits_get(struct dlb2_port *qm_port,
 		      enum dlb2_hw_queue_types type)
@@ -2666,192 +2658,6 @@ dlb2_construct_token_pop_qe(struct dlb2_port *qm_port, int idx)
 	qm_port->owed_tokens = 0;
 }
 
-static inline void
-dlb2_event_build_hcws(struct dlb2_port *qm_port,
-		      const struct rte_event ev[],
-		      int num,
-		      uint8_t *sched_type,
-		      uint8_t *queue_id)
-{
-	struct dlb2_enqueue_qe *qe;
-	uint16_t sched_word[4];
-	__m128i sse_qe[2];
-	int i;
-
-	qe = qm_port->qe4;
-
-	sse_qe[0] = _mm_setzero_si128();
-	sse_qe[1] = _mm_setzero_si128();
-
-	switch (num) {
-	case 4:
-		/* Construct the metadata portion of two HCWs in one 128b SSE
-		 * register. HCW metadata is constructed in the SSE registers
-		 * like so:
-		 * sse_qe[0][63:0]:   qe[0]'s metadata
-		 * sse_qe[0][127:64]: qe[1]'s metadata
-		 * sse_qe[1][63:0]:   qe[2]'s metadata
-		 * sse_qe[1][127:64]: qe[3]'s metadata
-		 */
-
-		/* Convert the event operation into a command byte and store it
-		 * in the metadata:
-		 * sse_qe[0][63:56]   = cmd_byte_map[is_directed][ev[0].op]
-		 * sse_qe[0][127:120] = cmd_byte_map[is_directed][ev[1].op]
-		 * sse_qe[1][63:56]   = cmd_byte_map[is_directed][ev[2].op]
-		 * sse_qe[1][127:120] = cmd_byte_map[is_directed][ev[3].op]
-		 */
-#define DLB2_QE_CMD_BYTE 7
-		sse_qe[0] = _mm_insert_epi8(sse_qe[0],
-				cmd_byte_map[qm_port->is_directed][ev[0].op],
-				DLB2_QE_CMD_BYTE);
-		sse_qe[0] = _mm_insert_epi8(sse_qe[0],
-				cmd_byte_map[qm_port->is_directed][ev[1].op],
-				DLB2_QE_CMD_BYTE + 8);
-		sse_qe[1] = _mm_insert_epi8(sse_qe[1],
-				cmd_byte_map[qm_port->is_directed][ev[2].op],
-				DLB2_QE_CMD_BYTE);
-		sse_qe[1] = _mm_insert_epi8(sse_qe[1],
-				cmd_byte_map[qm_port->is_directed][ev[3].op],
-				DLB2_QE_CMD_BYTE + 8);
-
-		/* Store priority, scheduling type, and queue ID in the sched
-		 * word array because these values are re-used when the
-		 * destination is a directed queue.
-		 */
-		sched_word[0] = EV_TO_DLB2_PRIO(ev[0].priority) << 10 |
-				sched_type[0] << 8 |
-				queue_id[0];
-		sched_word[1] = EV_TO_DLB2_PRIO(ev[1].priority) << 10 |
-				sched_type[1] << 8 |
-				queue_id[1];
-		sched_word[2] = EV_TO_DLB2_PRIO(ev[2].priority) << 10 |
-				sched_type[2] << 8 |
-				queue_id[2];
-		sched_word[3] = EV_TO_DLB2_PRIO(ev[3].priority) << 10 |
-				sched_type[3] << 8 |
-				queue_id[3];
-
-		/* Store the event priority, scheduling type, and queue ID in
-		 * the metadata:
-		 * sse_qe[0][31:16] = sched_word[0]
-		 * sse_qe[0][95:80] = sched_word[1]
-		 * sse_qe[1][31:16] = sched_word[2]
-		 * sse_qe[1][95:80] = sched_word[3]
-		 */
-#define DLB2_QE_QID_SCHED_WORD 1
-		sse_qe[0] = _mm_insert_epi16(sse_qe[0],
-					     sched_word[0],
-					     DLB2_QE_QID_SCHED_WORD);
-		sse_qe[0] = _mm_insert_epi16(sse_qe[0],
-					     sched_word[1],
-					     DLB2_QE_QID_SCHED_WORD + 4);
-		sse_qe[1] = _mm_insert_epi16(sse_qe[1],
-					     sched_word[2],
-					     DLB2_QE_QID_SCHED_WORD);
-		sse_qe[1] = _mm_insert_epi16(sse_qe[1],
-					     sched_word[3],
-					     DLB2_QE_QID_SCHED_WORD + 4);
-
-		/* If the destination is a load-balanced queue, store the lock
-		 * ID. If it is a directed queue, DLB places this field in
-		 * bytes 10-11 of the received QE, so we format it accordingly:
-		 * sse_qe[0][47:32]  = dir queue ? sched_word[0] : flow_id[0]
-		 * sse_qe[0][111:96] = dir queue ? sched_word[1] : flow_id[1]
-		 * sse_qe[1][47:32]  = dir queue ? sched_word[2] : flow_id[2]
-		 * sse_qe[1][111:96] = dir queue ? sched_word[3] : flow_id[3]
-		 */
-#define DLB2_QE_LOCK_ID_WORD 2
-		sse_qe[0] = _mm_insert_epi16(sse_qe[0],
-				(sched_type[0] == DLB2_SCHED_DIRECTED) ?
-					sched_word[0] : ev[0].flow_id,
-				DLB2_QE_LOCK_ID_WORD);
-		sse_qe[0] = _mm_insert_epi16(sse_qe[0],
-				(sched_type[1] == DLB2_SCHED_DIRECTED) ?
-					sched_word[1] : ev[1].flow_id,
-				DLB2_QE_LOCK_ID_WORD + 4);
-		sse_qe[1] = _mm_insert_epi16(sse_qe[1],
-				(sched_type[2] == DLB2_SCHED_DIRECTED) ?
-					sched_word[2] : ev[2].flow_id,
-				DLB2_QE_LOCK_ID_WORD);
-		sse_qe[1] = _mm_insert_epi16(sse_qe[1],
-				(sched_type[3] == DLB2_SCHED_DIRECTED) ?
-					sched_word[3] : ev[3].flow_id,
-				DLB2_QE_LOCK_ID_WORD + 4);
-
-		/* Store the event type and sub event type in the metadata:
-		 * sse_qe[0][15:0]  = flow_id[0]
-		 * sse_qe[0][79:64] = flow_id[1]
-		 * sse_qe[1][15:0]  = flow_id[2]
-		 * sse_qe[1][79:64] = flow_id[3]
-		 */
-#define DLB2_QE_EV_TYPE_WORD 0
-		sse_qe[0] = _mm_insert_epi16(sse_qe[0],
-					     ev[0].sub_event_type << 8 |
-						ev[0].event_type,
-					     DLB2_QE_EV_TYPE_WORD);
-		sse_qe[0] = _mm_insert_epi16(sse_qe[0],
-					     ev[1].sub_event_type << 8 |
-						ev[1].event_type,
-					     DLB2_QE_EV_TYPE_WORD + 4);
-		sse_qe[1] = _mm_insert_epi16(sse_qe[1],
-					     ev[2].sub_event_type << 8 |
-						ev[2].event_type,
-					     DLB2_QE_EV_TYPE_WORD);
-		sse_qe[1] = _mm_insert_epi16(sse_qe[1],
-					     ev[3].sub_event_type << 8 |
-						ev[3].event_type,
-					     DLB2_QE_EV_TYPE_WORD + 4);
-
-		/* Store the metadata to memory (use the double-precision
-		 * _mm_storeh_pd because there is no integer function for
-		 * storing the upper 64b):
-		 * qe[0] metadata = sse_qe[0][63:0]
-		 * qe[1] metadata = sse_qe[0][127:64]
-		 * qe[2] metadata = sse_qe[1][63:0]
-		 * qe[3] metadata = sse_qe[1][127:64]
-		 */
-		_mm_storel_epi64((__m128i *)&qe[0].u.opaque_data, sse_qe[0]);
-		_mm_storeh_pd((double *)&qe[1].u.opaque_data,
-			      (__m128d)sse_qe[0]);
-		_mm_storel_epi64((__m128i *)&qe[2].u.opaque_data, sse_qe[1]);
-		_mm_storeh_pd((double *)&qe[3].u.opaque_data,
-			      (__m128d)sse_qe[1]);
-
-		qe[0].data = ev[0].u64;
-		qe[1].data = ev[1].u64;
-		qe[2].data = ev[2].u64;
-		qe[3].data = ev[3].u64;
-
-		break;
-	case 3:
-	case 2:
-	case 1:
-		for (i = 0; i < num; i++) {
-			qe[i].cmd_byte =
-				cmd_byte_map[qm_port->is_directed][ev[i].op];
-			qe[i].sched_type = sched_type[i];
-			qe[i].data = ev[i].u64;
-			qe[i].qid = queue_id[i];
-			qe[i].priority = EV_TO_DLB2_PRIO(ev[i].priority);
-			qe[i].lock_id = ev[i].flow_id;
-			if (sched_type[i] == DLB2_SCHED_DIRECTED) {
-				struct dlb2_msg_info *info =
-					(struct dlb2_msg_info *)&qe[i].lock_id;
-
-				info->qid = queue_id[i];
-				info->sched_type = DLB2_SCHED_DIRECTED;
-				info->priority = qe[i].priority;
-			}
-			qe[i].u.event_type.major = ev[i].event_type;
-			qe[i].u.event_type.sub = ev[i].sub_event_type;
-		}
-		break;
-	case 0:
-		break;
-	}
-}
-
 static inline int
 dlb2_event_enqueue_prep(struct dlb2_eventdev_port *ev_port,
 			struct dlb2_port *qm_port,
drivers/event/dlb2/dlb2_avx512.c new file +267 -0

267 lines not on this page · raw message

drivers/event/dlb2/dlb2_priv.h +10 -0
index 4a06d649ab..e8d2d0c656 100644
@@ -377,6 +377,9 @@ struct dlb2_port {
 	struct dlb2_eventdev_port *ev_port; /* back ptr */
 	bool use_scalar; /* force usage of scalar code */
 	uint16_t hw_credit_quanta;
+#ifdef CC_AVX512_SUPPORT
+	bool use_avx512;
+#endif
 };
 
 /* Per-process per-port mmio and memory pointers */
@@ -686,6 +689,13 @@ int dlb2_parse_params(const char *params,
 		      struct dlb2_devargs *dlb2_args,
 		      uint8_t version);
 
+void dlb2_event_build_hcws(struct dlb2_port *qm_port,
+			   const struct rte_event ev[],
+			   int num,
+			   uint8_t *sched_type,
+			   uint8_t *queue_id);
+
+
 /* Extern globals */
 extern struct process_local_port_data dlb2_port[][DLB2_NUM_PORT_TYPES];
 
drivers/event/dlb2/dlb2_sve.c new file +219 -0

219 lines not on this page · raw message

drivers/event/dlb2/meson.build +53 -0

59 lines not on this page · raw message

Signature · 1 line
2.25.1
#14 lore raw

PATCH v7 1/1 event/dlb2: add support for single 512B write of 4 QEs

In reply to Timothy McDaniel

On Xeon, 512b accesses are available, so movdir64 instruction is able to perform 512b read and write to DLB producer port. In order for movdir64 to be able to pull its data from store buffers (store-buffer-forwarding) (before actual write), data should be in single 512b write format. This commit add change when code is built for Xeon with 512b AVX support to make single 512b write of all 4 QEs instead of 4x64b writes.

===

Changes since V6:
1) Check for AVX512VL only, removing checks for other AVX512 flags in meson.build
2) rename dlb2_sve.c to dlb2_sse.c

Changes since V5:
No code changes - just added --in-reply-to and copied Bruce

Changes since V4:
1) Add build-time control for avx512 support to meson.buildi, based on implementation found in lib/acl/meson.build
2) Add rte_vect_get_max_simd_bitwidth runtime check before using avx512 instructions

Changes since V3:
1) Renamed dlb2_noavx512.c to dlb2_sve.c, and fixed up meson.build for new file name.

Changes since V1:
1) Split out dlb2_event_build_hcws into two implementations, one that uses AVX512 instructions, and one that does not. Each implementation is in its own source file in order to avoid build errors if the compiler does not support the newer AVX512 instructions.
2) Update meson.build to and pull in appropriate source file based on whether the compiler supports AVX512VL
3) Check if target supports AVX512VL, and use appropriate implementation based on this runtime check.

---
 drivers/event/dlb2/dlb2.c        | 208 +-----------------------
 drivers/event/dlb2/dlb2_avx512.c | 267 +++++++++++++++++++++++++++++++
 drivers/event/dlb2/dlb2_priv.h   |  10 ++
 drivers/event/dlb2/dlb2_sse.c    | 219 +++++++++++++++++++++++++
 drivers/event/dlb2/dlb2_sve.c    | 219 +++++++++++++++++++++++++
 drivers/event/dlb2/meson.build   |  47 ++++++
 6 files changed, 769 insertions(+), 201 deletions(-)
 create mode 100644 drivers/event/dlb2/dlb2_avx512.c
 create mode 100644 drivers/event/dlb2/dlb2_sse.c
 create mode 100644 drivers/event/dlb2/dlb2_sve.c
drivers/event/dlb2/dlb2.c +7 -201
index 3641ed2942..0b70dc0f51 100644
@@ -1861,6 +1861,13 @@ dlb2_eventdev_port_setup(struct rte_eventdev *dev,
 
 	dev->data->ports[ev_port_id] = &dlb2->ev_ports[ev_port_id];
 
+#ifdef CC_AVX512_SUPPORT
+	if (rte_cpu_get_flag_enabled(RTE_CPUFLAG_AVX512VL) &&
+	    rte_vect_get_max_simd_bitwidth() >= RTE_VECT_SIMD_512)
+		ev_port->qm_port.use_avx512 = true;
+	else
+		ev_port->qm_port.use_avx512 = false;
+#endif
 	return 0;
 }
 
@@ -2457,21 +2464,6 @@ dlb2_eventdev_start(struct rte_eventdev *dev)
 	return 0;
 }
 
-static uint8_t cmd_byte_map[DLB2_NUM_PORT_TYPES][DLB2_NUM_HW_SCHED_TYPES] = {
-	{
-		/* Load-balanced cmd bytes */
-		[RTE_EVENT_OP_NEW] = DLB2_NEW_CMD_BYTE,
-		[RTE_EVENT_OP_FORWARD] = DLB2_FWD_CMD_BYTE,
-		[RTE_EVENT_OP_RELEASE] = DLB2_COMP_CMD_BYTE,
-	},
-	{
-		/* Directed cmd bytes */
-		[RTE_EVENT_OP_NEW] = DLB2_NEW_CMD_BYTE,
-		[RTE_EVENT_OP_FORWARD] = DLB2_NEW_CMD_BYTE,
-		[RTE_EVENT_OP_RELEASE] = DLB2_NOOP_CMD_BYTE,
-	},
-};
-
 static inline uint32_t
 dlb2_port_credits_get(struct dlb2_port *qm_port,
 		      enum dlb2_hw_queue_types type)
@@ -2666,192 +2658,6 @@ dlb2_construct_token_pop_qe(struct dlb2_port *qm_port, int idx)
 	qm_port->owed_tokens = 0;
 }
 
-static inline void
-dlb2_event_build_hcws(struct dlb2_port *qm_port,
-		      const struct rte_event ev[],
-		      int num,
-		      uint8_t *sched_type,
-		      uint8_t *queue_id)
-{
-	struct dlb2_enqueue_qe *qe;
-	uint16_t sched_word[4];
-	__m128i sse_qe[2];
-	int i;
-
-	qe = qm_port->qe4;
-
-	sse_qe[0] = _mm_setzero_si128();
-	sse_qe[1] = _mm_setzero_si128();
-
-	switch (num) {
-	case 4:
-		/* Construct the metadata portion of two HCWs in one 128b SSE
-		 * register. HCW metadata is constructed in the SSE registers
-		 * like so:
-		 * sse_qe[0][63:0]:   qe[0]'s metadata
-		 * sse_qe[0][127:64]: qe[1]'s metadata
-		 * sse_qe[1][63:0]:   qe[2]'s metadata
-		 * sse_qe[1][127:64]: qe[3]'s metadata
-		 */
-
-		/* Convert the event operation into a command byte and store it
-		 * in the metadata:
-		 * sse_qe[0][63:56]   = cmd_byte_map[is_directed][ev[0].op]
-		 * sse_qe[0][127:120] = cmd_byte_map[is_directed][ev[1].op]
-		 * sse_qe[1][63:56]   = cmd_byte_map[is_directed][ev[2].op]
-		 * sse_qe[1][127:120] = cmd_byte_map[is_directed][ev[3].op]
-		 */
-#define DLB2_QE_CMD_BYTE 7
-		sse_qe[0] = _mm_insert_epi8(sse_qe[0],
-				cmd_byte_map[qm_port->is_directed][ev[0].op],
-				DLB2_QE_CMD_BYTE);
-		sse_qe[0] = _mm_insert_epi8(sse_qe[0],
-				cmd_byte_map[qm_port->is_directed][ev[1].op],
-				DLB2_QE_CMD_BYTE + 8);
-		sse_qe[1] = _mm_insert_epi8(sse_qe[1],
-				cmd_byte_map[qm_port->is_directed][ev[2].op],
-				DLB2_QE_CMD_BYTE);
-		sse_qe[1] = _mm_insert_epi8(sse_qe[1],
-				cmd_byte_map[qm_port->is_directed][ev[3].op],
-				DLB2_QE_CMD_BYTE + 8);
-
-		/* Store priority, scheduling type, and queue ID in the sched
-		 * word array because these values are re-used when the
-		 * destination is a directed queue.
-		 */
-		sched_word[0] = EV_TO_DLB2_PRIO(ev[0].priority) << 10 |
-				sched_type[0] << 8 |
-				queue_id[0];
-		sched_word[1] = EV_TO_DLB2_PRIO(ev[1].priority) << 10 |
-				sched_type[1] << 8 |
-				queue_id[1];
-		sched_word[2] = EV_TO_DLB2_PRIO(ev[2].priority) << 10 |
-				sched_type[2] << 8 |
-				queue_id[2];
-		sched_word[3] = EV_TO_DLB2_PRIO(ev[3].priority) << 10 |
-				sched_type[3] << 8 |
-				queue_id[3];
-
-		/* Store the event priority, scheduling type, and queue ID in
-		 * the metadata:
-		 * sse_qe[0][31:16] = sched_word[0]
-		 * sse_qe[0][95:80] = sched_word[1]
-		 * sse_qe[1][31:16] = sched_word[2]
-		 * sse_qe[1][95:80] = sched_word[3]
-		 */
-#define DLB2_QE_QID_SCHED_WORD 1
-		sse_qe[0] = _mm_insert_epi16(sse_qe[0],
-					     sched_word[0],
-					     DLB2_QE_QID_SCHED_WORD);
-		sse_qe[0] = _mm_insert_epi16(sse_qe[0],
-					     sched_word[1],
-					     DLB2_QE_QID_SCHED_WORD + 4);
-		sse_qe[1] = _mm_insert_epi16(sse_qe[1],
-					     sched_word[2],
-					     DLB2_QE_QID_SCHED_WORD);
-		sse_qe[1] = _mm_insert_epi16(sse_qe[1],
-					     sched_word[3],
-					     DLB2_QE_QID_SCHED_WORD + 4);
-
-		/* If the destination is a load-balanced queue, store the lock
-		 * ID. If it is a directed queue, DLB places this field in
-		 * bytes 10-11 of the received QE, so we format it accordingly:
-		 * sse_qe[0][47:32]  = dir queue ? sched_word[0] : flow_id[0]
-		 * sse_qe[0][111:96] = dir queue ? sched_word[1] : flow_id[1]
-		 * sse_qe[1][47:32]  = dir queue ? sched_word[2] : flow_id[2]
-		 * sse_qe[1][111:96] = dir queue ? sched_word[3] : flow_id[3]
-		 */
-#define DLB2_QE_LOCK_ID_WORD 2
-		sse_qe[0] = _mm_insert_epi16(sse_qe[0],
-				(sched_type[0] == DLB2_SCHED_DIRECTED) ?
-					sched_word[0] : ev[0].flow_id,
-				DLB2_QE_LOCK_ID_WORD);
-		sse_qe[0] = _mm_insert_epi16(sse_qe[0],
-				(sched_type[1] == DLB2_SCHED_DIRECTED) ?
-					sched_word[1] : ev[1].flow_id,
-				DLB2_QE_LOCK_ID_WORD + 4);
-		sse_qe[1] = _mm_insert_epi16(sse_qe[1],
-				(sched_type[2] == DLB2_SCHED_DIRECTED) ?
-					sched_word[2] : ev[2].flow_id,
-				DLB2_QE_LOCK_ID_WORD);
-		sse_qe[1] = _mm_insert_epi16(sse_qe[1],
-				(sched_type[3] == DLB2_SCHED_DIRECTED) ?
-					sched_word[3] : ev[3].flow_id,
-				DLB2_QE_LOCK_ID_WORD + 4);
-
-		/* Store the event type and sub event type in the metadata:
-		 * sse_qe[0][15:0]  = flow_id[0]
-		 * sse_qe[0][79:64] = flow_id[1]
-		 * sse_qe[1][15:0]  = flow_id[2]
-		 * sse_qe[1][79:64] = flow_id[3]
-		 */
-#define DLB2_QE_EV_TYPE_WORD 0
-		sse_qe[0] = _mm_insert_epi16(sse_qe[0],
-					     ev[0].sub_event_type << 8 |
-						ev[0].event_type,
-					     DLB2_QE_EV_TYPE_WORD);
-		sse_qe[0] = _mm_insert_epi16(sse_qe[0],
-					     ev[1].sub_event_type << 8 |
-						ev[1].event_type,
-					     DLB2_QE_EV_TYPE_WORD + 4);
-		sse_qe[1] = _mm_insert_epi16(sse_qe[1],
-					     ev[2].sub_event_type << 8 |
-						ev[2].event_type,
-					     DLB2_QE_EV_TYPE_WORD);
-		sse_qe[1] = _mm_insert_epi16(sse_qe[1],
-					     ev[3].sub_event_type << 8 |
-						ev[3].event_type,
-					     DLB2_QE_EV_TYPE_WORD + 4);
-
-		/* Store the metadata to memory (use the double-precision
-		 * _mm_storeh_pd because there is no integer function for
-		 * storing the upper 64b):
-		 * qe[0] metadata = sse_qe[0][63:0]
-		 * qe[1] metadata = sse_qe[0][127:64]
-		 * qe[2] metadata = sse_qe[1][63:0]
-		 * qe[3] metadata = sse_qe[1][127:64]
-		 */
-		_mm_storel_epi64((__m128i *)&qe[0].u.opaque_data, sse_qe[0]);
-		_mm_storeh_pd((double *)&qe[1].u.opaque_data,
-			      (__m128d)sse_qe[0]);
-		_mm_storel_epi64((__m128i *)&qe[2].u.opaque_data, sse_qe[1]);
-		_mm_storeh_pd((double *)&qe[3].u.opaque_data,
-			      (__m128d)sse_qe[1]);
-
-		qe[0].data = ev[0].u64;
-		qe[1].data = ev[1].u64;
-		qe[2].data = ev[2].u64;
-		qe[3].data = ev[3].u64;
-
-		break;
-	case 3:
-	case 2:
-	case 1:
-		for (i = 0; i < num; i++) {
-			qe[i].cmd_byte =
-				cmd_byte_map[qm_port->is_directed][ev[i].op];
-			qe[i].sched_type = sched_type[i];
-			qe[i].data = ev[i].u64;
-			qe[i].qid = queue_id[i];
-			qe[i].priority = EV_TO_DLB2_PRIO(ev[i].priority);
-			qe[i].lock_id = ev[i].flow_id;
-			if (sched_type[i] == DLB2_SCHED_DIRECTED) {
-				struct dlb2_msg_info *info =
-					(struct dlb2_msg_info *)&qe[i].lock_id;
-
-				info->qid = queue_id[i];
-				info->sched_type = DLB2_SCHED_DIRECTED;
-				info->priority = qe[i].priority;
-			}
-			qe[i].u.event_type.major = ev[i].event_type;
-			qe[i].u.event_type.sub = ev[i].sub_event_type;
-		}
-		break;
-	case 0:
-		break;
-	}
-}
-
 static inline int
 dlb2_event_enqueue_prep(struct dlb2_eventdev_port *ev_port,
 			struct dlb2_port *qm_port,
drivers/event/dlb2/dlb2_avx512.c new file +267 -0

267 lines not on this page · raw message

drivers/event/dlb2/dlb2_priv.h +10 -0
index 4a06d649ab..e8d2d0c656 100644
@@ -377,6 +377,9 @@ struct dlb2_port {
 	struct dlb2_eventdev_port *ev_port; /* back ptr */
 	bool use_scalar; /* force usage of scalar code */
 	uint16_t hw_credit_quanta;
+#ifdef CC_AVX512_SUPPORT
+	bool use_avx512;
+#endif
 };
 
 /* Per-process per-port mmio and memory pointers */
@@ -686,6 +689,13 @@ int dlb2_parse_params(const char *params,
 		      struct dlb2_devargs *dlb2_args,
 		      uint8_t version);
 
+void dlb2_event_build_hcws(struct dlb2_port *qm_port,
+			   const struct rte_event ev[],
+			   int num,
+			   uint8_t *sched_type,
+			   uint8_t *queue_id);
+
+
 /* Extern globals */
 extern struct process_local_port_data dlb2_port[][DLB2_NUM_PORT_TYPES];
 
drivers/event/dlb2/dlb2_sse.c new file +219 -0

219 lines not on this page · raw message

drivers/event/dlb2/dlb2_sve.c new file +219 -0

219 lines not on this page · raw message

drivers/event/dlb2/meson.build +47 -0

53 lines not on this page · raw message

Signature · 1 line
2.25.1
#15 lore raw
Quoted 50 lines · Timothy McDaniel

On Xeon, 512b accesses are available, so movdir64 instruction is able to perform 512b read and write to DLB producer port. In order for movdir64 to be able to pull its data from store buffers (store-buffer-forwarding) (before actual write), data should be in single 512b write format. This commit add change when code is built for Xeon with 512b AVX support to make single 512b write of all 4 QEs instead of 4x64b writes.

===

Changes since V6:
1) Check for AVX512VL only, removing checks for other AVX512 flags in meson.build
2) rename dlb2_sve.c to dlb2_sse.c

Changes since V5:
No code changes - just added --in-reply-to and copied Bruce

Changes since V4:
1) Add build-time control for avx512 support to meson.buildi, based on implementation found in lib/acl/meson.build
2) Add rte_vect_get_max_simd_bitwidth runtime check before using avx512 instructions

Changes since V3:
1) Renamed dlb2_noavx512.c to dlb2_sve.c, and fixed up meson.build for new file name.

Changes since V1:
1) Split out dlb2_event_build_hcws into two implementations, one that uses AVX512 instructions, and one that does not. Each implementation is in its own source file in order to avoid build errors if the compiler does not support the newer AVX512 instructions.
2) Update meson.build to and pull in appropriate source file based on whether the compiler supports AVX512VL
3) Check if target supports AVX512VL, and use appropriate implementation based on this runtime check.

---
 drivers/event/dlb2/dlb2.c        | 208 +-----------------------
 drivers/event/dlb2/dlb2_avx512.c | 267 +++++++++++++++++++++++++++++++
 drivers/event/dlb2/dlb2_priv.h   |  10 ++
 drivers/event/dlb2/dlb2_sse.c    | 219 +++++++++++++++++++++++++
 drivers/event/dlb2/dlb2_sve.c    | 219 +++++++++++++++++++++++++
 drivers/event/dlb2/meson.build   |  47 ++++++
 6 files changed, 769 insertions(+), 201 deletions(-)
 create mode 100644 drivers/event/dlb2/dlb2_avx512.c
 create mode 100644 drivers/event/dlb2/dlb2_sse.c
 create mode 100644 drivers/event/dlb2/dlb2_sve.c

<snip>

Quoted 34 lines
drivers/event/dlb2/meson.build +26 -0
index f963589fd3..51ea5ec546 100644
@@ -19,6 +19,53 @@ sources = files(
         'dlb2_selftest.c',
 )
 
+# compile AVX512 version if:
+# we are building 64-bit binary (checked above) AND binutils
+# can generate proper code
+
+if binutils_ok
+
+    # compile AVX512 version if either:
+    # a. we have AVX512VL supported in minimum instruction set
+    #    baseline
+    # b. it's not minimum instruction set, but supported by
+    #    compiler
+    #
+    # in former case, just add avx512 C file to files list
+    # in latter case, compile c file to static lib, using correct
+    # compiler flags, and then have the .o file from static lib
+    # linked into main lib.
+
+    # check if all required flags already enabled (variant a).
+    dlb2_avx512_on = false
+    if cc.get_define(f, args: machine_args) == '__AVX512VL__'
+        dlb2_avx512_on = true
+    endif
+
+    if dlb2_avx512_on == true
+
+        sources += files('dlb2_avx512.c')

drivers/event/dlb2/meson.build sources = files( · line 57

Quoted 10 lines
drivers/event/dlb2/meson.build +10 -0
+        cflags += '-DCC_AVX512_SUPPORT'
+
+    elif cc.has_multi_arguments('-mavx512f', '-mavx512vl',
+                                '-mavx512cd', '-mavx512bw')
+
+        cflags += '-DCC_AVX512_SUPPORT'
+        avx512_tmplib = static_library('avx512_tmp',
+                               'dlb2_avx512.c',
+			       dependencies: [static_rte_eal,
+			                      static_rte_eventdev],

Minor nit - incorrect whitespace

Quoted 4 lines
drivers/event/dlb2/meson.build +4 -0
+                               c_args: cflags +
+                                       ['-mavx512f', '-mavx512vl',
+                                        '-mavx512cd', '-mavx512bw'])
+        objs += avx512_tmplib.extract_objects('dlb2_avx512.c')

drivers/event/dlb2/meson.build sources = files( · line 71

Quoted 10 lines
drivers/event/dlb2/meson.build +7 -0
+    else
+        sources += files('dlb2_sse.c')
+    endif
+else
+        sources += files('dlb2_sse.c')
+endif
+
 headers = files('rte_pmd_dlb2.h')
 
 deps += ['mbuf', 'mempool', 'ring', 'pci', 'bus_pci']

These meson.build file changes look ok to me now.

/Bruce

#16 lore raw

PATCH v8 1/1 event/dlb2: add support for single 512B write of 4 QEs

In reply to Timothy McDaniel

On Xeon, 512b accesses are available, so movdir64 instruction is able to perform 512b read and write to DLB producer port. In order for movdir64 to be able to pull its data from store buffers (store-buffer-forwarding) (before actual write), data should be in single 512b write format. This commit add change when code is built for Xeon with 512b AVX support to make single 512b write of all 4 QEs instead of 4x64b writes.

===

Changes since V7:
Fixed whitespace issue in meson.build

Changes since V6:
1) Check for AVX512VL only, removing checks for other AVX512 flags in meson.build
2) rename dlb2_sve.c to dlb2_sse.c

Changes since V5:
No code changes - just added --in-reply-to and copied Bruce

Changes since V4:
1) Add build-time control for avx512 support to meson.buildi, based on implementation found in lib/acl/meson.build
2) Add rte_vect_get_max_simd_bitwidth runtime check before using avx512 instructions

Changes since V3:
1) Renamed dlb2_noavx512.c to dlb2_sve.c, and fixed up meson.build for new file name.

Changes since V1:
1) Split out dlb2_event_build_hcws into two implementations, one that uses AVX512 instructions, and one that does not. Each implementation is in its own source file in order to avoid build errors if the compiler does not support the newer AVX512 instructions.
2) Update meson.build to and pull in appropriate source file based on whether the compiler supports AVX512VL
3) Check if target supports AVX512VL, and use appropriate implementation based on this runtime check.

---
 drivers/event/dlb2/dlb2.c        | 208 +-----------------------
 drivers/event/dlb2/dlb2_avx512.c | 267 +++++++++++++++++++++++++++++++
 drivers/event/dlb2/dlb2_priv.h   |  10 ++
 drivers/event/dlb2/dlb2_sse.c    | 219 +++++++++++++++++++++++++
 drivers/event/dlb2/dlb2_sve.c    | 219 +++++++++++++++++++++++++
 drivers/event/dlb2/meson.build   |  47 ++++++
 6 files changed, 769 insertions(+), 201 deletions(-)
 create mode 100644 drivers/event/dlb2/dlb2_avx512.c
 create mode 100644 drivers/event/dlb2/dlb2_sse.c
 create mode 100644 drivers/event/dlb2/dlb2_sve.c
drivers/event/dlb2/dlb2.c +7 -201
index 3641ed2942..0b70dc0f51 100644
@@ -1861,6 +1861,13 @@ dlb2_eventdev_port_setup(struct rte_eventdev *dev,
 
 	dev->data->ports[ev_port_id] = &dlb2->ev_ports[ev_port_id];
 
+#ifdef CC_AVX512_SUPPORT
+	if (rte_cpu_get_flag_enabled(RTE_CPUFLAG_AVX512VL) &&
+	    rte_vect_get_max_simd_bitwidth() >= RTE_VECT_SIMD_512)
+		ev_port->qm_port.use_avx512 = true;
+	else
+		ev_port->qm_port.use_avx512 = false;
+#endif
 	return 0;
 }
 
@@ -2457,21 +2464,6 @@ dlb2_eventdev_start(struct rte_eventdev *dev)
 	return 0;
 }
 
-static uint8_t cmd_byte_map[DLB2_NUM_PORT_TYPES][DLB2_NUM_HW_SCHED_TYPES] = {
-	{
-		/* Load-balanced cmd bytes */
-		[RTE_EVENT_OP_NEW] = DLB2_NEW_CMD_BYTE,
-		[RTE_EVENT_OP_FORWARD] = DLB2_FWD_CMD_BYTE,
-		[RTE_EVENT_OP_RELEASE] = DLB2_COMP_CMD_BYTE,
-	},
-	{
-		/* Directed cmd bytes */
-		[RTE_EVENT_OP_NEW] = DLB2_NEW_CMD_BYTE,
-		[RTE_EVENT_OP_FORWARD] = DLB2_NEW_CMD_BYTE,
-		[RTE_EVENT_OP_RELEASE] = DLB2_NOOP_CMD_BYTE,
-	},
-};
-
 static inline uint32_t
 dlb2_port_credits_get(struct dlb2_port *qm_port,
 		      enum dlb2_hw_queue_types type)
@@ -2666,192 +2658,6 @@ dlb2_construct_token_pop_qe(struct dlb2_port *qm_port, int idx)
 	qm_port->owed_tokens = 0;
 }
 
-static inline void
-dlb2_event_build_hcws(struct dlb2_port *qm_port,
-		      const struct rte_event ev[],
-		      int num,
-		      uint8_t *sched_type,
-		      uint8_t *queue_id)
-{
-	struct dlb2_enqueue_qe *qe;
-	uint16_t sched_word[4];
-	__m128i sse_qe[2];
-	int i;
-
-	qe = qm_port->qe4;
-
-	sse_qe[0] = _mm_setzero_si128();
-	sse_qe[1] = _mm_setzero_si128();
-
-	switch (num) {
-	case 4:
-		/* Construct the metadata portion of two HCWs in one 128b SSE
-		 * register. HCW metadata is constructed in the SSE registers
-		 * like so:
-		 * sse_qe[0][63:0]:   qe[0]'s metadata
-		 * sse_qe[0][127:64]: qe[1]'s metadata
-		 * sse_qe[1][63:0]:   qe[2]'s metadata
-		 * sse_qe[1][127:64]: qe[3]'s metadata
-		 */
-
-		/* Convert the event operation into a command byte and store it
-		 * in the metadata:
-		 * sse_qe[0][63:56]   = cmd_byte_map[is_directed][ev[0].op]
-		 * sse_qe[0][127:120] = cmd_byte_map[is_directed][ev[1].op]
-		 * sse_qe[1][63:56]   = cmd_byte_map[is_directed][ev[2].op]
-		 * sse_qe[1][127:120] = cmd_byte_map[is_directed][ev[3].op]
-		 */
-#define DLB2_QE_CMD_BYTE 7
-		sse_qe[0] = _mm_insert_epi8(sse_qe[0],
-				cmd_byte_map[qm_port->is_directed][ev[0].op],
-				DLB2_QE_CMD_BYTE);
-		sse_qe[0] = _mm_insert_epi8(sse_qe[0],
-				cmd_byte_map[qm_port->is_directed][ev[1].op],
-				DLB2_QE_CMD_BYTE + 8);
-		sse_qe[1] = _mm_insert_epi8(sse_qe[1],
-				cmd_byte_map[qm_port->is_directed][ev[2].op],
-				DLB2_QE_CMD_BYTE);
-		sse_qe[1] = _mm_insert_epi8(sse_qe[1],
-				cmd_byte_map[qm_port->is_directed][ev[3].op],
-				DLB2_QE_CMD_BYTE + 8);
-
-		/* Store priority, scheduling type, and queue ID in the sched
-		 * word array because these values are re-used when the
-		 * destination is a directed queue.
-		 */
-		sched_word[0] = EV_TO_DLB2_PRIO(ev[0].priority) << 10 |
-				sched_type[0] << 8 |
-				queue_id[0];
-		sched_word[1] = EV_TO_DLB2_PRIO(ev[1].priority) << 10 |
-				sched_type[1] << 8 |
-				queue_id[1];
-		sched_word[2] = EV_TO_DLB2_PRIO(ev[2].priority) << 10 |
-				sched_type[2] << 8 |
-				queue_id[2];
-		sched_word[3] = EV_TO_DLB2_PRIO(ev[3].priority) << 10 |
-				sched_type[3] << 8 |
-				queue_id[3];
-
-		/* Store the event priority, scheduling type, and queue ID in
-		 * the metadata:
-		 * sse_qe[0][31:16] = sched_word[0]
-		 * sse_qe[0][95:80] = sched_word[1]
-		 * sse_qe[1][31:16] = sched_word[2]
-		 * sse_qe[1][95:80] = sched_word[3]
-		 */
-#define DLB2_QE_QID_SCHED_WORD 1
-		sse_qe[0] = _mm_insert_epi16(sse_qe[0],
-					     sched_word[0],
-					     DLB2_QE_QID_SCHED_WORD);
-		sse_qe[0] = _mm_insert_epi16(sse_qe[0],
-					     sched_word[1],
-					     DLB2_QE_QID_SCHED_WORD + 4);
-		sse_qe[1] = _mm_insert_epi16(sse_qe[1],
-					     sched_word[2],
-					     DLB2_QE_QID_SCHED_WORD);
-		sse_qe[1] = _mm_insert_epi16(sse_qe[1],
-					     sched_word[3],
-					     DLB2_QE_QID_SCHED_WORD + 4);
-
-		/* If the destination is a load-balanced queue, store the lock
-		 * ID. If it is a directed queue, DLB places this field in
-		 * bytes 10-11 of the received QE, so we format it accordingly:
-		 * sse_qe[0][47:32]  = dir queue ? sched_word[0] : flow_id[0]
-		 * sse_qe[0][111:96] = dir queue ? sched_word[1] : flow_id[1]
-		 * sse_qe[1][47:32]  = dir queue ? sched_word[2] : flow_id[2]
-		 * sse_qe[1][111:96] = dir queue ? sched_word[3] : flow_id[3]
-		 */
-#define DLB2_QE_LOCK_ID_WORD 2
-		sse_qe[0] = _mm_insert_epi16(sse_qe[0],
-				(sched_type[0] == DLB2_SCHED_DIRECTED) ?
-					sched_word[0] : ev[0].flow_id,
-				DLB2_QE_LOCK_ID_WORD);
-		sse_qe[0] = _mm_insert_epi16(sse_qe[0],
-				(sched_type[1] == DLB2_SCHED_DIRECTED) ?
-					sched_word[1] : ev[1].flow_id,
-				DLB2_QE_LOCK_ID_WORD + 4);
-		sse_qe[1] = _mm_insert_epi16(sse_qe[1],
-				(sched_type[2] == DLB2_SCHED_DIRECTED) ?
-					sched_word[2] : ev[2].flow_id,
-				DLB2_QE_LOCK_ID_WORD);
-		sse_qe[1] = _mm_insert_epi16(sse_qe[1],
-				(sched_type[3] == DLB2_SCHED_DIRECTED) ?
-					sched_word[3] : ev[3].flow_id,
-				DLB2_QE_LOCK_ID_WORD + 4);
-
-		/* Store the event type and sub event type in the metadata:
-		 * sse_qe[0][15:0]  = flow_id[0]
-		 * sse_qe[0][79:64] = flow_id[1]
-		 * sse_qe[1][15:0]  = flow_id[2]
-		 * sse_qe[1][79:64] = flow_id[3]
-		 */
-#define DLB2_QE_EV_TYPE_WORD 0
-		sse_qe[0] = _mm_insert_epi16(sse_qe[0],
-					     ev[0].sub_event_type << 8 |
-						ev[0].event_type,
-					     DLB2_QE_EV_TYPE_WORD);
-		sse_qe[0] = _mm_insert_epi16(sse_qe[0],
-					     ev[1].sub_event_type << 8 |
-						ev[1].event_type,
-					     DLB2_QE_EV_TYPE_WORD + 4);
-		sse_qe[1] = _mm_insert_epi16(sse_qe[1],
-					     ev[2].sub_event_type << 8 |
-						ev[2].event_type,
-					     DLB2_QE_EV_TYPE_WORD);
-		sse_qe[1] = _mm_insert_epi16(sse_qe[1],
-					     ev[3].sub_event_type << 8 |
-						ev[3].event_type,
-					     DLB2_QE_EV_TYPE_WORD + 4);
-
-		/* Store the metadata to memory (use the double-precision
-		 * _mm_storeh_pd because there is no integer function for
-		 * storing the upper 64b):
-		 * qe[0] metadata = sse_qe[0][63:0]
-		 * qe[1] metadata = sse_qe[0][127:64]
-		 * qe[2] metadata = sse_qe[1][63:0]
-		 * qe[3] metadata = sse_qe[1][127:64]
-		 */
-		_mm_storel_epi64((__m128i *)&qe[0].u.opaque_data, sse_qe[0]);
-		_mm_storeh_pd((double *)&qe[1].u.opaque_data,
-			      (__m128d)sse_qe[0]);
-		_mm_storel_epi64((__m128i *)&qe[2].u.opaque_data, sse_qe[1]);
-		_mm_storeh_pd((double *)&qe[3].u.opaque_data,
-			      (__m128d)sse_qe[1]);
-
-		qe[0].data = ev[0].u64;
-		qe[1].data = ev[1].u64;
-		qe[2].data = ev[2].u64;
-		qe[3].data = ev[3].u64;
-
-		break;
-	case 3:
-	case 2:
-	case 1:
-		for (i = 0; i < num; i++) {
-			qe[i].cmd_byte =
-				cmd_byte_map[qm_port->is_directed][ev[i].op];
-			qe[i].sched_type = sched_type[i];
-			qe[i].data = ev[i].u64;
-			qe[i].qid = queue_id[i];
-			qe[i].priority = EV_TO_DLB2_PRIO(ev[i].priority);
-			qe[i].lock_id = ev[i].flow_id;
-			if (sched_type[i] == DLB2_SCHED_DIRECTED) {
-				struct dlb2_msg_info *info =
-					(struct dlb2_msg_info *)&qe[i].lock_id;
-
-				info->qid = queue_id[i];
-				info->sched_type = DLB2_SCHED_DIRECTED;
-				info->priority = qe[i].priority;
-			}
-			qe[i].u.event_type.major = ev[i].event_type;
-			qe[i].u.event_type.sub = ev[i].sub_event_type;
-		}
-		break;
-	case 0:
-		break;
-	}
-}
-
 static inline int
 dlb2_event_enqueue_prep(struct dlb2_eventdev_port *ev_port,
 			struct dlb2_port *qm_port,
drivers/event/dlb2/dlb2_avx512.c new file +267 -0

267 lines not on this page · raw message

drivers/event/dlb2/dlb2_priv.h +10 -0
index 4a06d649ab..e8d2d0c656 100644
@@ -377,6 +377,9 @@ struct dlb2_port {
 	struct dlb2_eventdev_port *ev_port; /* back ptr */
 	bool use_scalar; /* force usage of scalar code */
 	uint16_t hw_credit_quanta;
+#ifdef CC_AVX512_SUPPORT
+	bool use_avx512;
+#endif
 };
 
 /* Per-process per-port mmio and memory pointers */
@@ -686,6 +689,13 @@ int dlb2_parse_params(const char *params,
 		      struct dlb2_devargs *dlb2_args,
 		      uint8_t version);
 
+void dlb2_event_build_hcws(struct dlb2_port *qm_port,
+			   const struct rte_event ev[],
+			   int num,
+			   uint8_t *sched_type,
+			   uint8_t *queue_id);
+
+
 /* Extern globals */
 extern struct process_local_port_data dlb2_port[][DLB2_NUM_PORT_TYPES];
 
drivers/event/dlb2/dlb2_sse.c new file +219 -0

219 lines not on this page · raw message

drivers/event/dlb2/dlb2_sve.c new file +219 -0

219 lines not on this page · raw message

drivers/event/dlb2/meson.build +47 -0

53 lines not on this page · raw message

Signature · 1 line
2.25.1
#17 lore raw
Quoted 10 lines · Timothy McDaniel

On Xeon, 512b accesses are available, so movdir64 instruction is able to perform 512b read and write to DLB producer port. In order for movdir64 to be able to pull its data from store buffers (store-buffer-forwarding) (before actual write), data should be in single 512b write format. This commit add change when code is built for Xeon with 512b AVX support to make single 512b write of all 4 QEs instead of 4x64b writes.

@McDaniel, Timothy
Some cosmetic comments are below. Good to merge the next version. @Richardson, Bruce Hope you are OK with this version patch.

Quoted 1 line

+#ifdef CC_AVX512_SUPPORT

I think, We can avoid putting it under CC_AVX512_SUPPORT to avoid clutter.

Quoted 19 lines
drivers/event/dlb2/dlb2.c +6 -0
+       if (rte_cpu_get_flag_enabled(RTE_CPUFLAG_AVX512VL) &&
+           rte_vect_get_max_simd_bitwidth() >= RTE_VECT_SIMD_512)
+               ev_port->qm_port.use_avx512 = true;
+       else
+               ev_port->qm_port.use_avx512 = false;
+#endif
        return 0;
 }
@@ -2457,21 +2464,6 @@ dlb2_eventdev_start(struct rte_eventdev *dev)
        return 0;
 }
 
drivers/event/dlb2/dlb2_avx512.c new file +0 -0
new file mode 100644
index 0000000000..ce2d006006

drivers/event/dlb2/dlb2_avx512.c line 2

Quoted 2 lines
drivers/event/dlb2/dlb2_avx512.c new file +2 -0
@@ -0,0 +1,267 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2016-2020 Intel Corporation

Fix copyright year.

drivers/event/dlb2/dlb2_priv.h struct dlb2_port { · line 381

Quoted 12 lines
drivers/event/dlb2/dlb2_avx512.c new file +2 -0
+ */
+
drivers/event/dlb2/dlb2_priv.h +1 -0
index 4a06d649ab..e8d2d0c656 100644
@@ -377,6 +377,9 @@ struct dlb2_port {
        struct dlb2_eventdev_port *ev_port; /* back ptr */
        bool use_scalar; /* force usage of scalar code */
        uint16_t hw_credit_quanta;
 
+#ifdef CC_AVX512_SUPPORT

Not really need to be under compile time to avoid the compile-time clutter.

drivers/event/dlb2/dlb2_sse.c line 2

Quoted 12 lines
drivers/event/dlb2/dlb2_priv.h +2 -0
+       bool use_avx512;
+#endif
 };
 
drivers/event/dlb2/dlb2_sse.c new file +2 -0
new file mode 100644
index 0000000000..82f6588e2a
@@ -0,0 +1,219 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2016-2020 Intel Corporation

Fix copyright year.

drivers/event/dlb2/dlb2_sve.c line 2

Quoted 8 lines
drivers/event/dlb2/dlb2_sve.c new file +2 -0
new file mode 100644
index 0000000000..82f6588e2a
@@ -0,0 +1,219 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2016-2020 Intel Corporation

Fix copyright year.

#18 lore raw

PATCH v9 1/1 event/dlb2: add support for single 512B write of 4 QEs

In reply to Timothy McDaniel

On Xeon, 512b accesses are available, so movdir64 instruction is able to perform 512b read and write to DLB producer port. In order for movdir64 to be able to pull its data from store buffers (store-buffer-forwarding) (before actual write), data should be in single 512b write format. This commit add change when code is built for Xeon with 512b AVX support to make single 512b write of all 4 QEs instead of 4x64b writes.

===

Changes since V8:
1) Removed compile time control of AVX512 enablement
2) Fixed copyright year in all updated and new source files
3) Further refinement of meson.build - only add avx512vl flag to cflags, not others

Changes since V7:
Fixed whitespace issue in meson.build

Changes since V6:
1) Check for AVX512VL only, removing checks for other AVX512 flags in meson.build
2) rename dlb2_sve.c to dlb2_sse.c

Changes since V5:
No code changes - just added --in-reply-to and copied Bruce

Changes since V4:
1) Add build-time control for avx512 support to meson.buildi, based on implementation found in lib/acl/meson.build
2) Add rte_vect_get_max_simd_bitwidth runtime check before using avx512 instructions

Changes since V3:
1) Renamed dlb2_noavx512.c to dlb2_sve.c, and fixed up meson.build for new file name.

Changes since V1:
1) Split out dlb2_event_build_hcws into two implementations, one that uses AVX512 instructions, and one that does not. Each implementation is in its own source file in order to avoid build errors if the compiler does not support the newer AVX512 instructions.
2) Update meson.build to and pull in appropriate source file based on whether the compiler supports AVX512VL
3) Check if target supports AVX512VL, and use appropriate implementation based on this runtime check.

---
 drivers/event/dlb2/dlb2.c        | 209 +-----------------------
 drivers/event/dlb2/dlb2_avx512.c | 267 +++++++++++++++++++++++++++++++
 drivers/event/dlb2/dlb2_priv.h   |  10 +-
 drivers/event/dlb2/dlb2_sse.c    | 219 +++++++++++++++++++++++++
 drivers/event/dlb2/meson.build   |  44 +++++
 5 files changed, 546 insertions(+), 203 deletions(-)
 create mode 100644 drivers/event/dlb2/dlb2_avx512.c
 create mode 100644 drivers/event/dlb2/dlb2_sse.c
drivers/event/dlb2/dlb2.c +7 -202
index 3641ed2942..cf74a4a9f6 100644
@@ -1,5 +1,5 @@
 /* SPDX-License-Identifier: BSD-3-Clause
- * Copyright(c) 2016-2020 Intel Corporation
+ * Copyright(c) 2016-2022 Intel Corporation
  */
 
 #include <assert.h>
@@ -1861,6 +1861,12 @@ dlb2_eventdev_port_setup(struct rte_eventdev *dev,
 
 	dev->data->ports[ev_port_id] = &dlb2->ev_ports[ev_port_id];
 
+	if (rte_cpu_get_flag_enabled(RTE_CPUFLAG_AVX512VL) &&
+	    rte_vect_get_max_simd_bitwidth() >= RTE_VECT_SIMD_512)
+		ev_port->qm_port.use_avx512 = true;
+	else
+		ev_port->qm_port.use_avx512 = false;
+
 	return 0;
 }
 
@@ -2457,21 +2463,6 @@ dlb2_eventdev_start(struct rte_eventdev *dev)
 	return 0;
 }
 
-static uint8_t cmd_byte_map[DLB2_NUM_PORT_TYPES][DLB2_NUM_HW_SCHED_TYPES] = {
-	{
-		/* Load-balanced cmd bytes */
-		[RTE_EVENT_OP_NEW] = DLB2_NEW_CMD_BYTE,
-		[RTE_EVENT_OP_FORWARD] = DLB2_FWD_CMD_BYTE,
-		[RTE_EVENT_OP_RELEASE] = DLB2_COMP_CMD_BYTE,
-	},
-	{
-		/* Directed cmd bytes */
-		[RTE_EVENT_OP_NEW] = DLB2_NEW_CMD_BYTE,
-		[RTE_EVENT_OP_FORWARD] = DLB2_NEW_CMD_BYTE,
-		[RTE_EVENT_OP_RELEASE] = DLB2_NOOP_CMD_BYTE,
-	},
-};
-
 static inline uint32_t
 dlb2_port_credits_get(struct dlb2_port *qm_port,
 		      enum dlb2_hw_queue_types type)
@@ -2666,192 +2657,6 @@ dlb2_construct_token_pop_qe(struct dlb2_port *qm_port, int idx)
 	qm_port->owed_tokens = 0;
 }
 
-static inline void
-dlb2_event_build_hcws(struct dlb2_port *qm_port,
-		      const struct rte_event ev[],
-		      int num,
-		      uint8_t *sched_type,
-		      uint8_t *queue_id)
-{
-	struct dlb2_enqueue_qe *qe;
-	uint16_t sched_word[4];
-	__m128i sse_qe[2];
-	int i;
-
-	qe = qm_port->qe4;
-
-	sse_qe[0] = _mm_setzero_si128();
-	sse_qe[1] = _mm_setzero_si128();
-
-	switch (num) {
-	case 4:
-		/* Construct the metadata portion of two HCWs in one 128b SSE
-		 * register. HCW metadata is constructed in the SSE registers
-		 * like so:
-		 * sse_qe[0][63:0]:   qe[0]'s metadata
-		 * sse_qe[0][127:64]: qe[1]'s metadata
-		 * sse_qe[1][63:0]:   qe[2]'s metadata
-		 * sse_qe[1][127:64]: qe[3]'s metadata
-		 */
-
-		/* Convert the event operation into a command byte and store it
-		 * in the metadata:
-		 * sse_qe[0][63:56]   = cmd_byte_map[is_directed][ev[0].op]
-		 * sse_qe[0][127:120] = cmd_byte_map[is_directed][ev[1].op]
-		 * sse_qe[1][63:56]   = cmd_byte_map[is_directed][ev[2].op]
-		 * sse_qe[1][127:120] = cmd_byte_map[is_directed][ev[3].op]
-		 */
-#define DLB2_QE_CMD_BYTE 7
-		sse_qe[0] = _mm_insert_epi8(sse_qe[0],
-				cmd_byte_map[qm_port->is_directed][ev[0].op],
-				DLB2_QE_CMD_BYTE);
-		sse_qe[0] = _mm_insert_epi8(sse_qe[0],
-				cmd_byte_map[qm_port->is_directed][ev[1].op],
-				DLB2_QE_CMD_BYTE + 8);
-		sse_qe[1] = _mm_insert_epi8(sse_qe[1],
-				cmd_byte_map[qm_port->is_directed][ev[2].op],
-				DLB2_QE_CMD_BYTE);
-		sse_qe[1] = _mm_insert_epi8(sse_qe[1],
-				cmd_byte_map[qm_port->is_directed][ev[3].op],
-				DLB2_QE_CMD_BYTE + 8);
-
-		/* Store priority, scheduling type, and queue ID in the sched
-		 * word array because these values are re-used when the
-		 * destination is a directed queue.
-		 */
-		sched_word[0] = EV_TO_DLB2_PRIO(ev[0].priority) << 10 |
-				sched_type[0] << 8 |
-				queue_id[0];
-		sched_word[1] = EV_TO_DLB2_PRIO(ev[1].priority) << 10 |
-				sched_type[1] << 8 |
-				queue_id[1];
-		sched_word[2] = EV_TO_DLB2_PRIO(ev[2].priority) << 10 |
-				sched_type[2] << 8 |
-				queue_id[2];
-		sched_word[3] = EV_TO_DLB2_PRIO(ev[3].priority) << 10 |
-				sched_type[3] << 8 |
-				queue_id[3];
-
-		/* Store the event priority, scheduling type, and queue ID in
-		 * the metadata:
-		 * sse_qe[0][31:16] = sched_word[0]
-		 * sse_qe[0][95:80] = sched_word[1]
-		 * sse_qe[1][31:16] = sched_word[2]
-		 * sse_qe[1][95:80] = sched_word[3]
-		 */
-#define DLB2_QE_QID_SCHED_WORD 1
-		sse_qe[0] = _mm_insert_epi16(sse_qe[0],
-					     sched_word[0],
-					     DLB2_QE_QID_SCHED_WORD);
-		sse_qe[0] = _mm_insert_epi16(sse_qe[0],
-					     sched_word[1],
-					     DLB2_QE_QID_SCHED_WORD + 4);
-		sse_qe[1] = _mm_insert_epi16(sse_qe[1],
-					     sched_word[2],
-					     DLB2_QE_QID_SCHED_WORD);
-		sse_qe[1] = _mm_insert_epi16(sse_qe[1],
-					     sched_word[3],
-					     DLB2_QE_QID_SCHED_WORD + 4);
-
-		/* If the destination is a load-balanced queue, store the lock
-		 * ID. If it is a directed queue, DLB places this field in
-		 * bytes 10-11 of the received QE, so we format it accordingly:
-		 * sse_qe[0][47:32]  = dir queue ? sched_word[0] : flow_id[0]
-		 * sse_qe[0][111:96] = dir queue ? sched_word[1] : flow_id[1]
-		 * sse_qe[1][47:32]  = dir queue ? sched_word[2] : flow_id[2]
-		 * sse_qe[1][111:96] = dir queue ? sched_word[3] : flow_id[3]
-		 */
-#define DLB2_QE_LOCK_ID_WORD 2
-		sse_qe[0] = _mm_insert_epi16(sse_qe[0],
-				(sched_type[0] == DLB2_SCHED_DIRECTED) ?
-					sched_word[0] : ev[0].flow_id,
-				DLB2_QE_LOCK_ID_WORD);
-		sse_qe[0] = _mm_insert_epi16(sse_qe[0],
-				(sched_type[1] == DLB2_SCHED_DIRECTED) ?
-					sched_word[1] : ev[1].flow_id,
-				DLB2_QE_LOCK_ID_WORD + 4);
-		sse_qe[1] = _mm_insert_epi16(sse_qe[1],
-				(sched_type[2] == DLB2_SCHED_DIRECTED) ?
-					sched_word[2] : ev[2].flow_id,
-				DLB2_QE_LOCK_ID_WORD);
-		sse_qe[1] = _mm_insert_epi16(sse_qe[1],
-				(sched_type[3] == DLB2_SCHED_DIRECTED) ?
-					sched_word[3] : ev[3].flow_id,
-				DLB2_QE_LOCK_ID_WORD + 4);
-
-		/* Store the event type and sub event type in the metadata:
-		 * sse_qe[0][15:0]  = flow_id[0]
-		 * sse_qe[0][79:64] = flow_id[1]
-		 * sse_qe[1][15:0]  = flow_id[2]
-		 * sse_qe[1][79:64] = flow_id[3]
-		 */
-#define DLB2_QE_EV_TYPE_WORD 0
-		sse_qe[0] = _mm_insert_epi16(sse_qe[0],
-					     ev[0].sub_event_type << 8 |
-						ev[0].event_type,
-					     DLB2_QE_EV_TYPE_WORD);
-		sse_qe[0] = _mm_insert_epi16(sse_qe[0],
-					     ev[1].sub_event_type << 8 |
-						ev[1].event_type,
-					     DLB2_QE_EV_TYPE_WORD + 4);
-		sse_qe[1] = _mm_insert_epi16(sse_qe[1],
-					     ev[2].sub_event_type << 8 |
-						ev[2].event_type,
-					     DLB2_QE_EV_TYPE_WORD);
-		sse_qe[1] = _mm_insert_epi16(sse_qe[1],
-					     ev[3].sub_event_type << 8 |
-						ev[3].event_type,
-					     DLB2_QE_EV_TYPE_WORD + 4);
-
-		/* Store the metadata to memory (use the double-precision
-		 * _mm_storeh_pd because there is no integer function for
-		 * storing the upper 64b):
-		 * qe[0] metadata = sse_qe[0][63:0]
-		 * qe[1] metadata = sse_qe[0][127:64]
-		 * qe[2] metadata = sse_qe[1][63:0]
-		 * qe[3] metadata = sse_qe[1][127:64]
-		 */
-		_mm_storel_epi64((__m128i *)&qe[0].u.opaque_data, sse_qe[0]);
-		_mm_storeh_pd((double *)&qe[1].u.opaque_data,
-			      (__m128d)sse_qe[0]);
-		_mm_storel_epi64((__m128i *)&qe[2].u.opaque_data, sse_qe[1]);
-		_mm_storeh_pd((double *)&qe[3].u.opaque_data,
-			      (__m128d)sse_qe[1]);
-
-		qe[0].data = ev[0].u64;
-		qe[1].data = ev[1].u64;
-		qe[2].data = ev[2].u64;
-		qe[3].data = ev[3].u64;
-
-		break;
-	case 3:
-	case 2:
-	case 1:
-		for (i = 0; i < num; i++) {
-			qe[i].cmd_byte =
-				cmd_byte_map[qm_port->is_directed][ev[i].op];
-			qe[i].sched_type = sched_type[i];
-			qe[i].data = ev[i].u64;
-			qe[i].qid = queue_id[i];
-			qe[i].priority = EV_TO_DLB2_PRIO(ev[i].priority);
-			qe[i].lock_id = ev[i].flow_id;
-			if (sched_type[i] == DLB2_SCHED_DIRECTED) {
-				struct dlb2_msg_info *info =
-					(struct dlb2_msg_info *)&qe[i].lock_id;
-
-				info->qid = queue_id[i];
-				info->sched_type = DLB2_SCHED_DIRECTED;
-				info->priority = qe[i].priority;
-			}
-			qe[i].u.event_type.major = ev[i].event_type;
-			qe[i].u.event_type.sub = ev[i].sub_event_type;
-		}
-		break;
-	case 0:
-		break;
-	}
-}
-
 static inline int
 dlb2_event_enqueue_prep(struct dlb2_eventdev_port *ev_port,
 			struct dlb2_port *qm_port,
drivers/event/dlb2/dlb2_avx512.c new file +267 -0

267 lines not on this page · raw message

drivers/event/dlb2/dlb2_priv.h +9 -1
index 4a06d649ab..df69d57b83 100644
@@ -1,5 +1,5 @@
 /* SPDX-License-Identifier: BSD-3-Clause
- * Copyright(c) 2016-2020 Intel Corporation
+ * Copyright(c) 2016-2022 Intel Corporation
  */
 
 #ifndef _DLB2_PRIV_H_
@@ -377,6 +377,7 @@ struct dlb2_port {
 	struct dlb2_eventdev_port *ev_port; /* back ptr */
 	bool use_scalar; /* force usage of scalar code */
 	uint16_t hw_credit_quanta;
+	bool use_avx512;
 };
 
 /* Per-process per-port mmio and memory pointers */
@@ -686,6 +687,13 @@ int dlb2_parse_params(const char *params,
 		      struct dlb2_devargs *dlb2_args,
 		      uint8_t version);
 
+void dlb2_event_build_hcws(struct dlb2_port *qm_port,
+			   const struct rte_event ev[],
+			   int num,
+			   uint8_t *sched_type,
+			   uint8_t *queue_id);
+
+
 /* Extern globals */
 extern struct process_local_port_data dlb2_port[][DLB2_NUM_PORT_TYPES];
 
drivers/event/dlb2/dlb2_sse.c new file +219 -0

219 lines not on this page · raw message

drivers/event/dlb2/meson.build +44 -0

50 lines not on this page · raw message

Signature · 1 line
2.25.1
Applied
#19 lore raw
Quoted 10 lines · Timothy McDaniel

On Xeon, 512b accesses are available, so movdir64 instruction is able to perform 512b read and write to DLB producer port. In order for movdir64 to be able to pull its data from store buffers (store-buffer-forwarding) (before actual write), data should be in single 512b write format. This commit add change when code is built for Xeon with 512b AVX support to make single 512b write of all 4 QEs instead of 4x64b writes.

Applied to dpdk-next-net-eventdev/for-main. Thanks

Quoted 877 lines

===

Changes since V8:
1) Removed compile time control of AVX512 enablement
2) Fixed copyright year in all updated and new source files
3) Further refinement of meson.build - only add avx512vl flag to cflags, not others

Changes since V7:
Fixed whitespace issue in meson.build

Changes since V6:
1) Check for AVX512VL only, removing checks for other AVX512 flags in meson.build
2) rename dlb2_sve.c to dlb2_sse.c

Changes since V5:
No code changes - just added --in-reply-to and copied Bruce

Changes since V4:
1) Add build-time control for avx512 support to meson.buildi, based on implementation found in lib/acl/meson.build
2) Add rte_vect_get_max_simd_bitwidth runtime check before using avx512 instructions

Changes since V3:
1) Renamed dlb2_noavx512.c to dlb2_sve.c, and fixed up meson.build for new file name.

Changes since V1:
1) Split out dlb2_event_build_hcws into two implementations, one that uses AVX512 instructions, and one that does not. Each implementation is in its own source file in order to avoid build errors if the compiler does not support the newer AVX512 instructions.
2) Update meson.build to and pull in appropriate source file based on whether the compiler supports AVX512VL
3) Check if target supports AVX512VL, and use appropriate implementation based on this runtime check.

---
 drivers/event/dlb2/dlb2.c        | 209 +-----------------------
 drivers/event/dlb2/dlb2_avx512.c | 267 +++++++++++++++++++++++++++++++
 drivers/event/dlb2/dlb2_priv.h   |  10 +-
 drivers/event/dlb2/dlb2_sse.c    | 219 +++++++++++++++++++++++++
 drivers/event/dlb2/meson.build   |  44 +++++
 5 files changed, 546 insertions(+), 203 deletions(-)
 create mode 100644 drivers/event/dlb2/dlb2_avx512.c
 create mode 100644 drivers/event/dlb2/dlb2_sse.c
drivers/event/dlb2/dlb2.c +7 -202
index 3641ed2942..cf74a4a9f6 100644
@@ -1,5 +1,5 @@
 /* SPDX-License-Identifier: BSD-3-Clause
- * Copyright(c) 2016-2020 Intel Corporation
+ * Copyright(c) 2016-2022 Intel Corporation
  */
 
 #include <assert.h>
@@ -1861,6 +1861,12 @@ dlb2_eventdev_port_setup(struct rte_eventdev *dev,
 
        dev->data->ports[ev_port_id] = &dlb2->ev_ports[ev_port_id];
 
+       if (rte_cpu_get_flag_enabled(RTE_CPUFLAG_AVX512VL) &&
+           rte_vect_get_max_simd_bitwidth() >= RTE_VECT_SIMD_512)
+               ev_port->qm_port.use_avx512 = true;
+       else
+               ev_port->qm_port.use_avx512 = false;
+
        return 0;
 }
 
@@ -2457,21 +2463,6 @@ dlb2_eventdev_start(struct rte_eventdev *dev)
        return 0;
 }
 
-static uint8_t cmd_byte_map[DLB2_NUM_PORT_TYPES][DLB2_NUM_HW_SCHED_TYPES] = {
-       {
-               /* Load-balanced cmd bytes */
-               [RTE_EVENT_OP_NEW] = DLB2_NEW_CMD_BYTE,
-               [RTE_EVENT_OP_FORWARD] = DLB2_FWD_CMD_BYTE,
-               [RTE_EVENT_OP_RELEASE] = DLB2_COMP_CMD_BYTE,
-       },
-       {
-               /* Directed cmd bytes */
-               [RTE_EVENT_OP_NEW] = DLB2_NEW_CMD_BYTE,
-               [RTE_EVENT_OP_FORWARD] = DLB2_NEW_CMD_BYTE,
-               [RTE_EVENT_OP_RELEASE] = DLB2_NOOP_CMD_BYTE,
-       },
-};
-
 static inline uint32_t
 dlb2_port_credits_get(struct dlb2_port *qm_port,
                      enum dlb2_hw_queue_types type)
@@ -2666,192 +2657,6 @@ dlb2_construct_token_pop_qe(struct dlb2_port *qm_port, int idx)
        qm_port->owed_tokens = 0;
 }
 
-static inline void
-dlb2_event_build_hcws(struct dlb2_port *qm_port,
-                     const struct rte_event ev[],
-                     int num,
-                     uint8_t *sched_type,
-                     uint8_t *queue_id)
-{
-       struct dlb2_enqueue_qe *qe;
-       uint16_t sched_word[4];
-       __m128i sse_qe[2];
-       int i;
-
-       qe = qm_port->qe4;
-
-       sse_qe[0] = _mm_setzero_si128();
-       sse_qe[1] = _mm_setzero_si128();
-
-       switch (num) {
-       case 4:
-               /* Construct the metadata portion of two HCWs in one 128b SSE
-                * register. HCW metadata is constructed in the SSE registers
-                * like so:
-                * sse_qe[0][63:0]:   qe[0]'s metadata
-                * sse_qe[0][127:64]: qe[1]'s metadata
-                * sse_qe[1][63:0]:   qe[2]'s metadata
-                * sse_qe[1][127:64]: qe[3]'s metadata
-                */
-
-               /* Convert the event operation into a command byte and store it
-                * in the metadata:
-                * sse_qe[0][63:56]   = cmd_byte_map[is_directed][ev[0].op]
-                * sse_qe[0][127:120] = cmd_byte_map[is_directed][ev[1].op]
-                * sse_qe[1][63:56]   = cmd_byte_map[is_directed][ev[2].op]
-                * sse_qe[1][127:120] = cmd_byte_map[is_directed][ev[3].op]
-                */
-#define DLB2_QE_CMD_BYTE 7
-               sse_qe[0] = _mm_insert_epi8(sse_qe[0],
-                               cmd_byte_map[qm_port->is_directed][ev[0].op],
-                               DLB2_QE_CMD_BYTE);
-               sse_qe[0] = _mm_insert_epi8(sse_qe[0],
-                               cmd_byte_map[qm_port->is_directed][ev[1].op],
-                               DLB2_QE_CMD_BYTE + 8);
-               sse_qe[1] = _mm_insert_epi8(sse_qe[1],
-                               cmd_byte_map[qm_port->is_directed][ev[2].op],
-                               DLB2_QE_CMD_BYTE);
-               sse_qe[1] = _mm_insert_epi8(sse_qe[1],
-                               cmd_byte_map[qm_port->is_directed][ev[3].op],
-                               DLB2_QE_CMD_BYTE + 8);
-
-               /* Store priority, scheduling type, and queue ID in the sched
-                * word array because these values are re-used when the
-                * destination is a directed queue.
-                */
-               sched_word[0] = EV_TO_DLB2_PRIO(ev[0].priority) << 10 |
-                               sched_type[0] << 8 |
-                               queue_id[0];
-               sched_word[1] = EV_TO_DLB2_PRIO(ev[1].priority) << 10 |
-                               sched_type[1] << 8 |
-                               queue_id[1];
-               sched_word[2] = EV_TO_DLB2_PRIO(ev[2].priority) << 10 |
-                               sched_type[2] << 8 |
-                               queue_id[2];
-               sched_word[3] = EV_TO_DLB2_PRIO(ev[3].priority) << 10 |
-                               sched_type[3] << 8 |
-                               queue_id[3];
-
-               /* Store the event priority, scheduling type, and queue ID in
-                * the metadata:
-                * sse_qe[0][31:16] = sched_word[0]
-                * sse_qe[0][95:80] = sched_word[1]
-                * sse_qe[1][31:16] = sched_word[2]
-                * sse_qe[1][95:80] = sched_word[3]
-                */
-#define DLB2_QE_QID_SCHED_WORD 1
-               sse_qe[0] = _mm_insert_epi16(sse_qe[0],
-                                            sched_word[0],
-                                            DLB2_QE_QID_SCHED_WORD);
-               sse_qe[0] = _mm_insert_epi16(sse_qe[0],
-                                            sched_word[1],
-                                            DLB2_QE_QID_SCHED_WORD + 4);
-               sse_qe[1] = _mm_insert_epi16(sse_qe[1],
-                                            sched_word[2],
-                                            DLB2_QE_QID_SCHED_WORD);
-               sse_qe[1] = _mm_insert_epi16(sse_qe[1],
-                                            sched_word[3],
-                                            DLB2_QE_QID_SCHED_WORD + 4);
-
-               /* If the destination is a load-balanced queue, store the lock
-                * ID. If it is a directed queue, DLB places this field in
-                * bytes 10-11 of the received QE, so we format it accordingly:
-                * sse_qe[0][47:32]  = dir queue ? sched_word[0] : flow_id[0]
-                * sse_qe[0][111:96] = dir queue ? sched_word[1] : flow_id[1]
-                * sse_qe[1][47:32]  = dir queue ? sched_word[2] : flow_id[2]
-                * sse_qe[1][111:96] = dir queue ? sched_word[3] : flow_id[3]
-                */
-#define DLB2_QE_LOCK_ID_WORD 2
-               sse_qe[0] = _mm_insert_epi16(sse_qe[0],
-                               (sched_type[0] == DLB2_SCHED_DIRECTED) ?
-                                       sched_word[0] : ev[0].flow_id,
-                               DLB2_QE_LOCK_ID_WORD);
-               sse_qe[0] = _mm_insert_epi16(sse_qe[0],
-                               (sched_type[1] == DLB2_SCHED_DIRECTED) ?
-                                       sched_word[1] : ev[1].flow_id,
-                               DLB2_QE_LOCK_ID_WORD + 4);
-               sse_qe[1] = _mm_insert_epi16(sse_qe[1],
-                               (sched_type[2] == DLB2_SCHED_DIRECTED) ?
-                                       sched_word[2] : ev[2].flow_id,
-                               DLB2_QE_LOCK_ID_WORD);
-               sse_qe[1] = _mm_insert_epi16(sse_qe[1],
-                               (sched_type[3] == DLB2_SCHED_DIRECTED) ?
-                                       sched_word[3] : ev[3].flow_id,
-                               DLB2_QE_LOCK_ID_WORD + 4);
-
-               /* Store the event type and sub event type in the metadata:
-                * sse_qe[0][15:0]  = flow_id[0]
-                * sse_qe[0][79:64] = flow_id[1]
-                * sse_qe[1][15:0]  = flow_id[2]
-                * sse_qe[1][79:64] = flow_id[3]
-                */
-#define DLB2_QE_EV_TYPE_WORD 0
-               sse_qe[0] = _mm_insert_epi16(sse_qe[0],
-                                            ev[0].sub_event_type << 8 |
-                                               ev[0].event_type,
-                                            DLB2_QE_EV_TYPE_WORD);
-               sse_qe[0] = _mm_insert_epi16(sse_qe[0],
-                                            ev[1].sub_event_type << 8 |
-                                               ev[1].event_type,
-                                            DLB2_QE_EV_TYPE_WORD + 4);
-               sse_qe[1] = _mm_insert_epi16(sse_qe[1],
-                                            ev[2].sub_event_type << 8 |
-                                               ev[2].event_type,
-                                            DLB2_QE_EV_TYPE_WORD);
-               sse_qe[1] = _mm_insert_epi16(sse_qe[1],
-                                            ev[3].sub_event_type << 8 |
-                                               ev[3].event_type,
-                                            DLB2_QE_EV_TYPE_WORD + 4);
-
-               /* Store the metadata to memory (use the double-precision
-                * _mm_storeh_pd because there is no integer function for
-                * storing the upper 64b):
-                * qe[0] metadata = sse_qe[0][63:0]
-                * qe[1] metadata = sse_qe[0][127:64]
-                * qe[2] metadata = sse_qe[1][63:0]
-                * qe[3] metadata = sse_qe[1][127:64]
-                */
-               _mm_storel_epi64((__m128i *)&qe[0].u.opaque_data, sse_qe[0]);
-               _mm_storeh_pd((double *)&qe[1].u.opaque_data,
-                             (__m128d)sse_qe[0]);
-               _mm_storel_epi64((__m128i *)&qe[2].u.opaque_data, sse_qe[1]);
-               _mm_storeh_pd((double *)&qe[3].u.opaque_data,
-                             (__m128d)sse_qe[1]);
-
-               qe[0].data = ev[0].u64;
-               qe[1].data = ev[1].u64;
-               qe[2].data = ev[2].u64;
-               qe[3].data = ev[3].u64;
-
-               break;
-       case 3:
-       case 2:
-       case 1:
-               for (i = 0; i < num; i++) {
-                       qe[i].cmd_byte =
-                               cmd_byte_map[qm_port->is_directed][ev[i].op];
-                       qe[i].sched_type = sched_type[i];
-                       qe[i].data = ev[i].u64;
-                       qe[i].qid = queue_id[i];
-                       qe[i].priority = EV_TO_DLB2_PRIO(ev[i].priority);
-                       qe[i].lock_id = ev[i].flow_id;
-                       if (sched_type[i] == DLB2_SCHED_DIRECTED) {
-                               struct dlb2_msg_info *info =
-                                       (struct dlb2_msg_info *)&qe[i].lock_id;
-
-                               info->qid = queue_id[i];
-                               info->sched_type = DLB2_SCHED_DIRECTED;
-                               info->priority = qe[i].priority;
-                       }
-                       qe[i].u.event_type.major = ev[i].event_type;
-                       qe[i].u.event_type.sub = ev[i].sub_event_type;
-               }
-               break;
-       case 0:
-               break;
-       }
-}
-
 static inline int
 dlb2_event_enqueue_prep(struct dlb2_eventdev_port *ev_port,
                        struct dlb2_port *qm_port,
drivers/event/dlb2/dlb2_avx512.c new file +267 -0
new file mode 100644
index 0000000000..d4aaa04a01
@@ -0,0 +1,267 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2022 Intel Corporation
+ */
+
+#include <stdint.h>
+#include <stdbool.h>
+
+#include "dlb2_priv.h"
+#include "dlb2_iface.h"
+#include "dlb2_inline_fns.h"
+
+/*
+ * This source file is used when the compiler on the build machine
+ * supports AVX512VL. We will perform a runtime check before actually
+ * executing those instructions.
+ */
+
+static uint8_t cmd_byte_map[DLB2_NUM_PORT_TYPES][DLB2_NUM_HW_SCHED_TYPES] = {
+       {
+               /* Load-balanced cmd bytes */
+               [RTE_EVENT_OP_NEW] = DLB2_NEW_CMD_BYTE,
+               [RTE_EVENT_OP_FORWARD] = DLB2_FWD_CMD_BYTE,
+               [RTE_EVENT_OP_RELEASE] = DLB2_COMP_CMD_BYTE,
+       },
+       {
+               /* Directed cmd bytes */
+               [RTE_EVENT_OP_NEW] = DLB2_NEW_CMD_BYTE,
+               [RTE_EVENT_OP_FORWARD] = DLB2_NEW_CMD_BYTE,
+               [RTE_EVENT_OP_RELEASE] = DLB2_NOOP_CMD_BYTE,
+       },
+};
+
+void
+dlb2_event_build_hcws(struct dlb2_port *qm_port,
+                     const struct rte_event ev[],
+                     int num,
+                     uint8_t *sched_type,
+                     uint8_t *queue_id)
+{
+       struct dlb2_enqueue_qe *qe;
+       uint16_t sched_word[4];
+       __m128i sse_qe[2];
+       int i;
+
+       qe = qm_port->qe4;
+
+       sse_qe[0] = _mm_setzero_si128();
+       sse_qe[1] = _mm_setzero_si128();
+
+       switch (num) {
+       case 4:
+               /* Construct the metadata portion of two HCWs in one 128b SSE
+                * register. HCW metadata is constructed in the SSE registers
+                * like so:
+                * sse_qe[0][63:0]:   qe[0]'s metadata
+                * sse_qe[0][127:64]: qe[1]'s metadata
+                * sse_qe[1][63:0]:   qe[2]'s metadata
+                * sse_qe[1][127:64]: qe[3]'s metadata
+                */
+
+               /* Convert the event operation into a command byte and store it
+                * in the metadata:
+                * sse_qe[0][63:56]   = cmd_byte_map[is_directed][ev[0].op]
+                * sse_qe[0][127:120] = cmd_byte_map[is_directed][ev[1].op]
+                * sse_qe[1][63:56]   = cmd_byte_map[is_directed][ev[2].op]
+                * sse_qe[1][127:120] = cmd_byte_map[is_directed][ev[3].op]
+                */
+#define DLB2_QE_CMD_BYTE 7
+               sse_qe[0] = _mm_insert_epi8(sse_qe[0],
+                               cmd_byte_map[qm_port->is_directed][ev[0].op],
+                               DLB2_QE_CMD_BYTE);
+               sse_qe[0] = _mm_insert_epi8(sse_qe[0],
+                               cmd_byte_map[qm_port->is_directed][ev[1].op],
+                               DLB2_QE_CMD_BYTE + 8);
+               sse_qe[1] = _mm_insert_epi8(sse_qe[1],
+                               cmd_byte_map[qm_port->is_directed][ev[2].op],
+                               DLB2_QE_CMD_BYTE);
+               sse_qe[1] = _mm_insert_epi8(sse_qe[1],
+                               cmd_byte_map[qm_port->is_directed][ev[3].op],
+                               DLB2_QE_CMD_BYTE + 8);
+
+               /* Store priority, scheduling type, and queue ID in the sched
+                * word array because these values are re-used when the
+                * destination is a directed queue.
+                */
+               sched_word[0] = EV_TO_DLB2_PRIO(ev[0].priority) << 10 |
+                               sched_type[0] << 8 |
+                               queue_id[0];
+               sched_word[1] = EV_TO_DLB2_PRIO(ev[1].priority) << 10 |
+                               sched_type[1] << 8 |
+                               queue_id[1];
+               sched_word[2] = EV_TO_DLB2_PRIO(ev[2].priority) << 10 |
+                               sched_type[2] << 8 |
+                               queue_id[2];
+               sched_word[3] = EV_TO_DLB2_PRIO(ev[3].priority) << 10 |
+                               sched_type[3] << 8 |
+                               queue_id[3];
+
+               /* Store the event priority, scheduling type, and queue ID in
+                * the metadata:
+                * sse_qe[0][31:16] = sched_word[0]
+                * sse_qe[0][95:80] = sched_word[1]
+                * sse_qe[1][31:16] = sched_word[2]
+                * sse_qe[1][95:80] = sched_word[3]
+                */
+#define DLB2_QE_QID_SCHED_WORD 1
+               sse_qe[0] = _mm_insert_epi16(sse_qe[0],
+                                            sched_word[0],
+                                            DLB2_QE_QID_SCHED_WORD);
+               sse_qe[0] = _mm_insert_epi16(sse_qe[0],
+                                            sched_word[1],
+                                            DLB2_QE_QID_SCHED_WORD + 4);
+               sse_qe[1] = _mm_insert_epi16(sse_qe[1],
+                                            sched_word[2],
+                                            DLB2_QE_QID_SCHED_WORD);
+               sse_qe[1] = _mm_insert_epi16(sse_qe[1],
+                                            sched_word[3],
+                                            DLB2_QE_QID_SCHED_WORD + 4);
+
+               /* If the destination is a load-balanced queue, store the lock
+                * ID. If it is a directed queue, DLB places this field in
+                * bytes 10-11 of the received QE, so we format it accordingly:
+                * sse_qe[0][47:32]  = dir queue ? sched_word[0] : flow_id[0]
+                * sse_qe[0][111:96] = dir queue ? sched_word[1] : flow_id[1]
+                * sse_qe[1][47:32]  = dir queue ? sched_word[2] : flow_id[2]
+                * sse_qe[1][111:96] = dir queue ? sched_word[3] : flow_id[3]
+                */
+#define DLB2_QE_LOCK_ID_WORD 2
+               sse_qe[0] = _mm_insert_epi16(sse_qe[0],
+                               (sched_type[0] == DLB2_SCHED_DIRECTED) ?
+                                       sched_word[0] : ev[0].flow_id,
+                               DLB2_QE_LOCK_ID_WORD);
+               sse_qe[0] = _mm_insert_epi16(sse_qe[0],
+                               (sched_type[1] == DLB2_SCHED_DIRECTED) ?
+                                       sched_word[1] : ev[1].flow_id,
+                               DLB2_QE_LOCK_ID_WORD + 4);
+               sse_qe[1] = _mm_insert_epi16(sse_qe[1],
+                               (sched_type[2] == DLB2_SCHED_DIRECTED) ?
+                                       sched_word[2] : ev[2].flow_id,
+                               DLB2_QE_LOCK_ID_WORD);
+               sse_qe[1] = _mm_insert_epi16(sse_qe[1],
+                               (sched_type[3] == DLB2_SCHED_DIRECTED) ?
+                                       sched_word[3] : ev[3].flow_id,
+                               DLB2_QE_LOCK_ID_WORD + 4);
+
+               /* Store the event type and sub event type in the metadata:
+                * sse_qe[0][15:0]  = flow_id[0]
+                * sse_qe[0][79:64] = flow_id[1]
+                * sse_qe[1][15:0]  = flow_id[2]
+                * sse_qe[1][79:64] = flow_id[3]
+                */
+#define DLB2_QE_EV_TYPE_WORD 0
+               sse_qe[0] = _mm_insert_epi16(sse_qe[0],
+                                            ev[0].sub_event_type << 8 |
+                                               ev[0].event_type,
+                                            DLB2_QE_EV_TYPE_WORD);
+               sse_qe[0] = _mm_insert_epi16(sse_qe[0],
+                                            ev[1].sub_event_type << 8 |
+                                               ev[1].event_type,
+                                            DLB2_QE_EV_TYPE_WORD + 4);
+               sse_qe[1] = _mm_insert_epi16(sse_qe[1],
+                                            ev[2].sub_event_type << 8 |
+                                               ev[2].event_type,
+                                            DLB2_QE_EV_TYPE_WORD);
+               sse_qe[1] = _mm_insert_epi16(sse_qe[1],
+                                            ev[3].sub_event_type << 8 |
+                                               ev[3].event_type,
+                                            DLB2_QE_EV_TYPE_WORD + 4);
+
+               if (qm_port->use_avx512) {
+
+                       /*
+                        * 1) Build avx512 QE store and build each
+                        *    QE individually as XMM register
+                        * 2) Merge the 4 XMM registers/QEs into single AVX512
+                        *    register
+                        * 3) Store single avx512 register to &qe[0] (4x QEs
+                        *    stored in 1x store)
+                        */
+
+                       __m128i v_qe0 = _mm_setzero_si128();
+                       uint64_t meta = _mm_extract_epi64(sse_qe[0], 0);
+                       v_qe0 = _mm_insert_epi64(v_qe0, ev[0].u64, 0);
+                       v_qe0 = _mm_insert_epi64(v_qe0, meta, 1);
+
+                       __m128i v_qe1 = _mm_setzero_si128();
+                       meta = _mm_extract_epi64(sse_qe[0], 1);
+                       v_qe1 = _mm_insert_epi64(v_qe1, ev[1].u64, 0);
+                       v_qe1 = _mm_insert_epi64(v_qe1, meta, 1);
+
+                       __m128i v_qe2 = _mm_setzero_si128();
+                       meta = _mm_extract_epi64(sse_qe[1], 0);
+                       v_qe2 = _mm_insert_epi64(v_qe2, ev[2].u64, 0);
+                       v_qe2 = _mm_insert_epi64(v_qe2, meta, 1);
+
+                       __m128i v_qe3 = _mm_setzero_si128();
+                       meta = _mm_extract_epi64(sse_qe[1], 1);
+                       v_qe3 = _mm_insert_epi64(v_qe3, ev[3].u64, 0);
+                       v_qe3 = _mm_insert_epi64(v_qe3, meta, 1);
+
+                       /* we have 4x XMM registers, one per QE. */
+                       __m512i v_all_qes = _mm512_setzero_si512();
+                       v_all_qes = _mm512_inserti32x4(v_all_qes, v_qe0, 0);
+                       v_all_qes = _mm512_inserti32x4(v_all_qes, v_qe1, 1);
+                       v_all_qes = _mm512_inserti32x4(v_all_qes, v_qe2, 2);
+                       v_all_qes = _mm512_inserti32x4(v_all_qes, v_qe3, 3);
+
+                       /*
+                        * store the 4x QEs in a single register to the scratch
+                        * space of the PMD
+                        */
+                       _mm512_store_si512(&qe[0], v_all_qes);
+
+               } else {
+
+                       /*
+                        * Store the metadata to memory (use the double-precision
+                        * _mm_storeh_pd because there is no integer function for
+                        * storing the upper 64b):
+                        * qe[0] metadata = sse_qe[0][63:0]
+                        * qe[1] metadata = sse_qe[0][127:64]
+                        * qe[2] metadata = sse_qe[1][63:0]
+                        * qe[3] metadata = sse_qe[1][127:64]
+                        */
+                       _mm_storel_epi64((__m128i *)&qe[0].u.opaque_data,
+                                        sse_qe[0]);
+                       _mm_storeh_pd((double *)&qe[1].u.opaque_data,
+                                     (__m128d)sse_qe[0]);
+                       _mm_storel_epi64((__m128i *)&qe[2].u.opaque_data,
+                                        sse_qe[1]);
+                       _mm_storeh_pd((double *)&qe[3].u.opaque_data,
+                                     (__m128d)sse_qe[1]);
+
+                       qe[0].data = ev[0].u64;
+                       qe[1].data = ev[1].u64;
+                       qe[2].data = ev[2].u64;
+                       qe[3].data = ev[3].u64;
+               }
+
+               break;
+       case 3:
+       case 2:
+       case 1:
+               for (i = 0; i < num; i++) {
+                       qe[i].cmd_byte =
+                               cmd_byte_map[qm_port->is_directed][ev[i].op];
+                       qe[i].sched_type = sched_type[i];
+                       qe[i].data = ev[i].u64;
+                       qe[i].qid = queue_id[i];
+                       qe[i].priority = EV_TO_DLB2_PRIO(ev[i].priority);
+                       qe[i].lock_id = ev[i].flow_id;
+                       if (sched_type[i] == DLB2_SCHED_DIRECTED) {
+                               struct dlb2_msg_info *info =
+                                       (struct dlb2_msg_info *)&qe[i].lock_id;
+
+                               info->qid = queue_id[i];
+                               info->sched_type = DLB2_SCHED_DIRECTED;
+                               info->priority = qe[i].priority;
+                       }
+                       qe[i].u.event_type.major = ev[i].event_type;
+                       qe[i].u.event_type.sub = ev[i].sub_event_type;
+               }
+               break;
+       case 0:
+               break;
+       }
+}
drivers/event/dlb2/dlb2_priv.h +9 -1
index 4a06d649ab..df69d57b83 100644
@@ -1,5 +1,5 @@
 /* SPDX-License-Identifier: BSD-3-Clause
- * Copyright(c) 2016-2020 Intel Corporation
+ * Copyright(c) 2016-2022 Intel Corporation
  */
 
 #ifndef _DLB2_PRIV_H_
@@ -377,6 +377,7 @@ struct dlb2_port {
        struct dlb2_eventdev_port *ev_port; /* back ptr */
        bool use_scalar; /* force usage of scalar code */
        uint16_t hw_credit_quanta;
+       bool use_avx512;
 };
 
 /* Per-process per-port mmio and memory pointers */
@@ -686,6 +687,13 @@ int dlb2_parse_params(const char *params,
                      struct dlb2_devargs *dlb2_args,
                      uint8_t version);
 
+void dlb2_event_build_hcws(struct dlb2_port *qm_port,
+                          const struct rte_event ev[],
+                          int num,
+                          uint8_t *sched_type,
+                          uint8_t *queue_id);
+
+
 /* Extern globals */
 extern struct process_local_port_data dlb2_port[][DLB2_NUM_PORT_TYPES];
 
drivers/event/dlb2/dlb2_sse.c new file +219 -0
new file mode 100644
index 0000000000..8fc12d47f7
@@ -0,0 +1,219 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2022 Intel Corporation
+ */
+
+#include <stdint.h>
+#include <stdbool.h>
+
+#include "dlb2_priv.h"
+#include "dlb2_iface.h"
+#include "dlb2_inline_fns.h"
+
+/*
+ * This source file is only used when the compiler on the build machine
+ * does not support AVX512VL.
+ */
+
+static uint8_t cmd_byte_map[DLB2_NUM_PORT_TYPES][DLB2_NUM_HW_SCHED_TYPES] = {
+       {
+               /* Load-balanced cmd bytes */
+               [RTE_EVENT_OP_NEW] = DLB2_NEW_CMD_BYTE,
+               [RTE_EVENT_OP_FORWARD] = DLB2_FWD_CMD_BYTE,
+               [RTE_EVENT_OP_RELEASE] = DLB2_COMP_CMD_BYTE,
+       },
+       {
+               /* Directed cmd bytes */
+               [RTE_EVENT_OP_NEW] = DLB2_NEW_CMD_BYTE,
+               [RTE_EVENT_OP_FORWARD] = DLB2_NEW_CMD_BYTE,
+               [RTE_EVENT_OP_RELEASE] = DLB2_NOOP_CMD_BYTE,
+       },
+};
+
+void
+dlb2_event_build_hcws(struct dlb2_port *qm_port,
+                     const struct rte_event ev[],
+                     int num,
+                     uint8_t *sched_type,
+                     uint8_t *queue_id)
+{
+       struct dlb2_enqueue_qe *qe;
+       uint16_t sched_word[4];
+       __m128i sse_qe[2];
+       int i;
+
+       qe = qm_port->qe4;
+
+       sse_qe[0] = _mm_setzero_si128();
+       sse_qe[1] = _mm_setzero_si128();
+
+       switch (num) {
+       case 4:
+               /* Construct the metadata portion of two HCWs in one 128b SSE
+                * register. HCW metadata is constructed in the SSE registers
+                * like so:
+                * sse_qe[0][63:0]:   qe[0]'s metadata
+                * sse_qe[0][127:64]: qe[1]'s metadata
+                * sse_qe[1][63:0]:   qe[2]'s metadata
+                * sse_qe[1][127:64]: qe[3]'s metadata
+                */
+
+               /* Convert the event operation into a command byte and store it
+                * in the metadata:
+                * sse_qe[0][63:56]   = cmd_byte_map[is_directed][ev[0].op]
+                * sse_qe[0][127:120] = cmd_byte_map[is_directed][ev[1].op]
+                * sse_qe[1][63:56]   = cmd_byte_map[is_directed][ev[2].op]
+                * sse_qe[1][127:120] = cmd_byte_map[is_directed][ev[3].op]
+                */
+#define DLB2_QE_CMD_BYTE 7
+               sse_qe[0] = _mm_insert_epi8(sse_qe[0],
+                               cmd_byte_map[qm_port->is_directed][ev[0].op],
+                               DLB2_QE_CMD_BYTE);
+               sse_qe[0] = _mm_insert_epi8(sse_qe[0],
+                               cmd_byte_map[qm_port->is_directed][ev[1].op],
+                               DLB2_QE_CMD_BYTE + 8);
+               sse_qe[1] = _mm_insert_epi8(sse_qe[1],
+                               cmd_byte_map[qm_port->is_directed][ev[2].op],
+                               DLB2_QE_CMD_BYTE);
+               sse_qe[1] = _mm_insert_epi8(sse_qe[1],
+                               cmd_byte_map[qm_port->is_directed][ev[3].op],
+                               DLB2_QE_CMD_BYTE + 8);
+
+               /* Store priority, scheduling type, and queue ID in the sched
+                * word array because these values are re-used when the
+                * destination is a directed queue.
+                */
+               sched_word[0] = EV_TO_DLB2_PRIO(ev[0].priority) << 10 |
+                               sched_type[0] << 8 |
+                               queue_id[0];
+               sched_word[1] = EV_TO_DLB2_PRIO(ev[1].priority) << 10 |
+                               sched_type[1] << 8 |
+                               queue_id[1];
+               sched_word[2] = EV_TO_DLB2_PRIO(ev[2].priority) << 10 |
+                               sched_type[2] << 8 |
+                               queue_id[2];
+               sched_word[3] = EV_TO_DLB2_PRIO(ev[3].priority) << 10 |
+                               sched_type[3] << 8 |
+                               queue_id[3];
+
+               /* Store the event priority, scheduling type, and queue ID in
+                * the metadata:
+                * sse_qe[0][31:16] = sched_word[0]
+                * sse_qe[0][95:80] = sched_word[1]
+                * sse_qe[1][31:16] = sched_word[2]
+                * sse_qe[1][95:80] = sched_word[3]
+                */
+#define DLB2_QE_QID_SCHED_WORD 1
+               sse_qe[0] = _mm_insert_epi16(sse_qe[0],
+                                            sched_word[0],
+                                            DLB2_QE_QID_SCHED_WORD);
+               sse_qe[0] = _mm_insert_epi16(sse_qe[0],
+                                            sched_word[1],
+                                            DLB2_QE_QID_SCHED_WORD + 4);
+               sse_qe[1] = _mm_insert_epi16(sse_qe[1],
+                                            sched_word[2],
+                                            DLB2_QE_QID_SCHED_WORD);
+               sse_qe[1] = _mm_insert_epi16(sse_qe[1],
+                                            sched_word[3],
+                                            DLB2_QE_QID_SCHED_WORD + 4);
+
+               /* If the destination is a load-balanced queue, store the lock
+                * ID. If it is a directed queue, DLB places this field in
+                * bytes 10-11 of the received QE, so we format it accordingly:
+                * sse_qe[0][47:32]  = dir queue ? sched_word[0] : flow_id[0]
+                * sse_qe[0][111:96] = dir queue ? sched_word[1] : flow_id[1]
+                * sse_qe[1][47:32]  = dir queue ? sched_word[2] : flow_id[2]
+                * sse_qe[1][111:96] = dir queue ? sched_word[3] : flow_id[3]
+                */
+#define DLB2_QE_LOCK_ID_WORD 2
+               sse_qe[0] = _mm_insert_epi16(sse_qe[0],
+                               (sched_type[0] == DLB2_SCHED_DIRECTED) ?
+                                       sched_word[0] : ev[0].flow_id,
+                               DLB2_QE_LOCK_ID_WORD);
+               sse_qe[0] = _mm_insert_epi16(sse_qe[0],
+                               (sched_type[1] == DLB2_SCHED_DIRECTED) ?
+                                       sched_word[1] : ev[1].flow_id,
+                               DLB2_QE_LOCK_ID_WORD + 4);
+               sse_qe[1] = _mm_insert_epi16(sse_qe[1],
+                               (sched_type[2] == DLB2_SCHED_DIRECTED) ?
+                                       sched_word[2] : ev[2].flow_id,
+                               DLB2_QE_LOCK_ID_WORD);
+               sse_qe[1] = _mm_insert_epi16(sse_qe[1],
+                               (sched_type[3] == DLB2_SCHED_DIRECTED) ?
+                                       sched_word[3] : ev[3].flow_id,
+                               DLB2_QE_LOCK_ID_WORD + 4);
+
+               /* Store the event type and sub event type in the metadata:
+                * sse_qe[0][15:0]  = flow_id[0]
+                * sse_qe[0][79:64] = flow_id[1]
+                * sse_qe[1][15:0]  = flow_id[2]
+                * sse_qe[1][79:64] = flow_id[3]
+                */
+#define DLB2_QE_EV_TYPE_WORD 0
+               sse_qe[0] = _mm_insert_epi16(sse_qe[0],
+                                            ev[0].sub_event_type << 8 |
+                                               ev[0].event_type,
+                                            DLB2_QE_EV_TYPE_WORD);
+               sse_qe[0] = _mm_insert_epi16(sse_qe[0],
+                                            ev[1].sub_event_type << 8 |
+                                               ev[1].event_type,
+                                            DLB2_QE_EV_TYPE_WORD + 4);
+               sse_qe[1] = _mm_insert_epi16(sse_qe[1],
+                                            ev[2].sub_event_type << 8 |
+                                               ev[2].event_type,
+                                            DLB2_QE_EV_TYPE_WORD);
+               sse_qe[1] = _mm_insert_epi16(sse_qe[1],
+                                            ev[3].sub_event_type << 8 |
+                                               ev[3].event_type,
+                                            DLB2_QE_EV_TYPE_WORD + 4);
+
+               /*
+                * Store the metadata to memory (use the double-precision
+                * _mm_storeh_pd because there is no integer function for
+                * storing the upper 64b):
+                * qe[0] metadata = sse_qe[0][63:0]
+                * qe[1] metadata = sse_qe[0][127:64]
+                * qe[2] metadata = sse_qe[1][63:0]
+                * qe[3] metadata = sse_qe[1][127:64]
+                */
+               _mm_storel_epi64((__m128i *)&qe[0].u.opaque_data,
+                                sse_qe[0]);
+               _mm_storeh_pd((double *)&qe[1].u.opaque_data,
+                             (__m128d)sse_qe[0]);
+               _mm_storel_epi64((__m128i *)&qe[2].u.opaque_data,
+                                sse_qe[1]);
+               _mm_storeh_pd((double *)&qe[3].u.opaque_data,
+                                     (__m128d)sse_qe[1]);
+
+               qe[0].data = ev[0].u64;
+               qe[1].data = ev[1].u64;
+               qe[2].data = ev[2].u64;
+               qe[3].data = ev[3].u64;
+
+               break;
+       case 3:
+       case 2:
+       case 1:
+               for (i = 0; i < num; i++) {
+                       qe[i].cmd_byte =
+                               cmd_byte_map[qm_port->is_directed][ev[i].op];
+                       qe[i].sched_type = sched_type[i];
+                       qe[i].data = ev[i].u64;
+                       qe[i].qid = queue_id[i];
+                       qe[i].priority = EV_TO_DLB2_PRIO(ev[i].priority);
+                       qe[i].lock_id = ev[i].flow_id;
+                       if (sched_type[i] == DLB2_SCHED_DIRECTED) {
+                               struct dlb2_msg_info *info =
+                                       (struct dlb2_msg_info *)&qe[i].lock_id;
+
+                               info->qid = queue_id[i];
+                               info->sched_type = DLB2_SCHED_DIRECTED;
+                               info->priority = qe[i].priority;
+                       }
+                       qe[i].u.event_type.major = ev[i].event_type;
+                       qe[i].u.event_type.sub = ev[i].sub_event_type;
+               }
+               break;
+       case 0:
+               break;
+       }
+}
drivers/event/dlb2/meson.build +44 -1
index f963589fd3..c08f480570 100644
@@ -19,6 +19,50 @@ sources = files(
         'dlb2_selftest.c',
 )
 
+# compile AVX512 version if:
+# we are building 64-bit binary (checked above) AND binutils
+# can generate proper code
+
+if binutils_ok
+
+    # compile AVX512 version if either:
+    # a. we have AVX512VL supported in minimum instruction set
+    #    baseline
+    # b. it's not minimum instruction set, but supported by
+    #    compiler
+    #
+    # in former case, just add avx512 C file to files list
+    # in latter case, compile c file to static lib, using correct
+    # compiler flags, and then have the .o file from static lib
+    # linked into main lib.
+
+    # check if all required flags already enabled (variant a).
+    dlb2_avx512_on = false
+    if cc.get_define(f, args: machine_args) == '__AVX512VL__'
+        dlb2_avx512_on = true
+    endif
+
+    if dlb2_avx512_on == true
+
+        sources += files('dlb2_avx512.c')
+        cflags += '-DCC_AVX512_SUPPORT'
+
+    elif cc.has_multi_arguments('-mavx512vl')
+
+        cflags += '-DCC_AVX512_SUPPORT'
+        avx512_tmplib = static_library('avx512_tmp',
+                               'dlb2_avx512.c',
+                               dependencies: [static_rte_eal,
+                                             static_rte_eventdev],
+                               c_args: cflags + ['-mavx512vl'])
+        objs += avx512_tmplib.extract_objects('dlb2_avx512.c')
+    else
+        sources += files('dlb2_sse.c')
+    endif
+else
+        sources += files('dlb2_sse.c')
+endif
+
 headers = files('rte_pmd_dlb2.h')
 
 deps += ['mbuf', 'mempool', 'ring', 'pci', 'bus_pci']
--

2.25.1