On Wed, Nov 11, 2026 at 9:22 AM Sarkar, Tirthendu
<[email protected]> wrote:
>
> On Mon, Nov 9, 2026 at 6:25 PM Jerin Jacob <[email protected]> wrote:
> > Lets get the performance  numbers for SLB vs DSW based on same test
> > case so  that we can decide.
> > Performance and scalability will be the aspect to decide the usage of
> > YET ANOTHER SW driver.
>
> Hi Pravin,
>
> A few points on top of Stephen's review, plus some early numbers since
> Jerin asked for SLB vs DSW data.
>
> +1 to Stephen's two Errors in patch 2 (reorder slot reuse when RELEASE
> returns credits before the slot drains, and the lost wakeup in
> slb_reorder_drain()) and to the credit-threshold issue in patch 1.
> Those look like the ones that can lose or strand events.
>
> Additional comments:
>
> 1. slb_event.c, slb_event_enqueue_burst_generic(): the return value of
>    rte_event_ring_enqueue_burst() is ignored on every path and the
>    function always returns events_len. Correctness then depends
>    entirely on credits guaranteeing ring space. If that ever fails
>    (e.g. the credit-threshold or reorder issues above, or application
>    misuse), events are silently dropped and their credits leak. At
>    minimum, check the return value and report a short enqueue.
>    Because the burst is sorted by destination queue before enqueue,
>    a clean prefix count isn't possible after a partial failure, so
>    this probably needs a space check up front or an explicit design
>    statement that rings can never fill.
>
> 2. RTE_VERIFY(num_forward + num_release <= cur_pending) in the
>    enqueue fast path aborts the whole process on application misuse
>    (forwarding more events than were dequeued on that port). Please
>    fail the enqueue and set rte_errno instead.
>
> 3. slb_configure(): max_inflight = RTE_MAX(nb_events_limit,
>    nb_ports * SLB_PORT_MAX_CREDITS), so the device can hold more
>    events than the application configured via nb_events_limit. If
>    that is intended (to avoid credit-cache deadlock), please document
>    it in slb.rst.
>
> 4. slb_queue_setup() ignores queue_conf->priority; priority comes only
>    from the link priority, yet dev_info reports
>    max_event_queue_priority_levels = 2. Either honour queue priority or
>    report 1 and document that priority is per link.
>
> Performance
> -----------
> Preliminary data from dpdk-test-eventdev perf_queue, series applied on
> v26.11-rc2, release build, Xeon 6505P (2x12C), physical cores only,
> turbo on, default device settings, worker_deq_depth 16, 1024 flows.
> Mpps, 1 synthetic producer, workers on socket 0:
>
>   stlist   driver   1w     2w     4w     8w
>   p          slb       79.7   71.5   44.5   34.0
>   p          dsw     50.1   46.3   45.1   41.9
>   a          slb       54.3   65.3   57.0   43.9
>   a          dsw     50.3   47.3   46.7   40.5
>   a,a,a    slb      20.8    16.9   22.9   26.7
>   a,a,a    dsw    20.8    18.4   20.1   18.2
>   o          slb      61.7    29.5   36.6   27.4
>   o          sw        7.7    10.0   11.7   13.7
>   o,a       slb      36.0    19.5   28.3   28.9
>   o,a       sw       3.8       5.7     7.5      7.2
>
> (event_dsw does not support ordered queues, so ordered rows are
> against event_sw.)
>
> Observations:
> - SLB is ahead at low worker counts but loses throughput faster as
>   workers are added on single-stage parallel/atomic queues, which is
>   consistent with all workers contending on one MP/MC ring per queue.
> - Ordered queues are well ahead of event_sw (the only other SW PMD with
>   ordered support), but SLB ordered throughput halves going from 1 to
>   2 workers (61.7 -> 29.5 Mpps, reproduced), so the "close to
>   parallel" claim only holds for a single worker (parallel: 79.7 ->
>   71.5). This looks like the serialized reorder drain.
> - With workers spanning both sockets (16/20 workers) all drivers drop
>   sharply; SLB falls to 5-10 Mpps vs DSW 3-14 depending on stlist.
> - Note that with multiple producers perf_queue creates a separate
>   queue set per producer, which splits SLB's per-queue contention; SLB
>   scales very well in that mode (4 producers, 8 workers, atomic:
>   ~235 Mpps vs ~158 for DSW at worker_deq_depth 16), but that does not
>   reflect a pipeline where all traffic shares one atomic queue.
> - order_queue passes with up to 16 workers. In that test SLB slows down
>   as workers are added: with 8 workers it sustained ~1.0 M events/s vs
>   ~2.5 M events/s for event_sw (steady-state rate from the progress
>   counter, 20M events); with 1-2 workers SLB was faster than event_sw
>   (rough end-to-end timings, ~3.2 vs ~1.6-2.1 M events/s).
>
> These are untuned runs. In the 1-producer table the SLB/DSW atomic and
> a,a,a rows, DSW parallel and SLB ordered were run twice and agreed
> within ~5%; the other rows are single runs. Treat them as indicative.
> It would help if v2 included your own perf_queue/pipeline numbers with
> the exact command lines, ideally including a shared-queue case and
> workers on more than one socket.
>
> Thanks,
> Tirthendu

Thanks Tirtha for the readings and comments. The main intention of introducing
SLB is to bridge the current gap where there is no distributed
software eventdev
supporting ordered queues and priorities. Current event_sw has a limitation of
single core scheduling limit. You can see it clearly from below
performance tests
where event_sw saturates early.
SLB provides option for moving from hardware with accelerator supporting
ordered queue and priority to new hardware where accelerator is not available.

Performance Testing using test-eventdev on Patch V2 where all current feedback
is implemented.

$ dpdk-test-eventdev -l 0-13 event_xx  -- --test=perf_queue
--plcores=1 --wlcores=5-8
--nb_flows=64 --nb_pkts=200000000 --worker_deq_depth=64 --slist=x

--slist=x   SLB     DSW     SW
--------------------------------------
p             108.0      53       30.0
a              76.5     54       26.8
o              78 .0    NA      17.9
p,p,p,p     47.8     27        8.6
a,a,a,a     24.8     28.2     7.2
o,o,o,o     22.4     NA       4.8
p,a,p,a     33.8     26.5     7.0

Scaling test
$ dpdk-test-eventdev -l 0-15 event_xx  -- --test=perf_queue
--plcores=1,2 --wlcores=5-x
--nb_flows=64 --nb_pkts=200000000 --worker_deq_depth=64 --slist=x

workers   --slist=x       SLB      DSW      SW
----------------------------------------------
      2   p             134.0    110.4    26.2
      4   p             206.0    101.8    29.1
      6   p             180.0      93.7    30.1
      8   p             141.0      82.5    28.9
     10   p            119.5      74.7    27.2

      2   a              76.5     114.0    29.9
      4   a             112.8    107.0    26.2
      6   a             126.2      93.4    23.8
      8   a             122.0      87.4    22.8
     10   a            111.2      77.5    21.1

      2   o               55.1      NA     18.8
      4   o               82.4      NA     19.2
      6   o             106.4      NA     19.1
      8   o             124.0      NA     18.7
     10   o            135.5      NA     17.5

Priority Testing (My own test cases)
----------------------------------------------------------------------
 QID | Priority | Events | Avg Latency | Min Latency | Max Latency
----------------------------------------------------------------------
   0 | HIGH         | 250000 |   11738.30 ns |        462.81 ns |  466678.00 ns
   1 | HIGH         | 250000 |   11810.06 ns |        512.92 ns |  468083.85 ns
   2 | NORMAL   | 250000 | 902657.03 ns | 381863.42 ns | 1156287.10 ns
   3 | NORMAL   | 250000 | 908277.05 ns | 383254.46 ns | 1161556.63 ns
-----------------------------------------------------------------------

Reply via email to