doc/guides/sample_app_ug/eventdev_pipeline.rst

   1 ..  SPDX-License-Identifier: BSD-3-Clause
   2     Copyright(c) 2017 Intel Corporation.
   3
   4 Eventdev Pipeline Sample Application
   5 ====================================
   6
   7 The eventdev pipeline sample application is a sample app that demonstrates
   8 the usage of the eventdev API using the software PMD. It shows how an
   9 application can configure a pipeline and assign a set of worker cores to
  10 perform the processing required.
  11
  12 The application has a range of command line arguments allowing it to be
  13 configured for various numbers worker cores, stages,queue depths and cycles per
  14 stage of work. This is useful for performance testing as well as quickly testing
  15 a particular pipeline configuration.
  16
  17
  18 Compiling the Application
  19 -------------------------
  20
  21 To compile the sample application see :doc:`compiling`.
  22
  23 The application is located in the ``examples`` sub-directory.
  24
  25
  26
  27 Running the Application
  28 -----------------------
  29
  30 The application has a lot of command line options. This allows specification of
  31 the eventdev PMD to use, and a number of attributes of the processing pipeline
  32 options.
  33
  34 An example eventdev pipeline running with the software eventdev PMD using
  35 these settings is shown below:
  36
  37  * ``-r1``: core mask 0x1 for RX
  38  * ``-t1``: core mask 0x1 for TX
  39  * ``-e4``: core mask 0x4 for the software scheduler
  40  * ``-w FF00``: core mask for worker cores, 8 cores from 8th to 16th
  41  * ``-s4``: 4 atomic stages
  42  * ``-n0``: process infinite packets (run forever)
  43  * ``-c32``: worker dequeue depth of 32
  44  * ``-W1000``: do 1000 cycles of work per packet in each stage
  45  * ``-D``: dump statistics on exit
  46
  47 .. code-block:: console
  48
  49     ./build/eventdev_pipeline --vdev event_sw0 -- -r1 -t1 -e4 -w FF00 -s4 -n0 -c32 -W1000 -D
  50
  51 The application has some sanity checking built-in, so if there is a function
  52 (eg; the RX core) which doesn't have a cpu core mask assigned, the application
  53 will print an error message:
  54
  55 .. code-block:: console
  56
  57   Core part of pipeline was not assigned any cores. This will stall the
  58   pipeline, please check core masks (use -h for details on setting core masks):
  59           rx: 0
  60           tx: 1
  61
  62 Configuration of the eventdev is covered in detail in the programmers guide,
  63 see the Event Device Library section.
  64
  65
  66 Observing the Application
  67 -------------------------
  68
  69 At runtime the eventdev pipeline application prints out a summary of the
  70 configuration, and some runtime statistics like packets per second. On exit the
  71 worker statistics are printed, along with a full dump of the PMD statistics if
  72 required. The following sections show sample output for each of the output
  73 types.
  74
  75 Configuration
  76 ~~~~~~~~~~~~~
  77
  78 This provides an overview of the pipeline,
  79 scheduling type at each stage, and parameters to options such as how many
  80 flows to use and what eventdev PMD is in use. See the following sample output
  81 for details:
  82
  83 .. code-block:: console
  84
  85   Config:
  86         ports: 2
  87         workers: 8
  88         packets: 0
  89         priorities: 1
  90         Queue-prio: 0
  91         qid0 type: atomic
  92         Cores available: 44
  93         Cores used: 10
  94         Eventdev 0: event_sw
  95   Stages:
  96         Stage 0, Type Atomic    Priority = 128
  97         Stage 1, Type Atomic    Priority = 128
  98         Stage 2, Type Atomic    Priority = 128
  99         Stage 3, Type Atomic    Priority = 128
 100
 101 Runtime
 102 ~~~~~~~
 103
 104 At runtime, the statistics of the consumer are printed, stating the number of
 105 packets received, runtime in milliseconds, average mpps, and current mpps.
 106
 107 .. code-block:: console
 108
 109   # consumer RX= xxxxxxx, time yyyy ms, avg z.zzz mpps [current w.www mpps]
 110
 111 Shutdown
 112 ~~~~~~~~
 113
 114 At shutdown, the application prints the number of packets received and
 115 transmitted, and an overview of the distribution of work across worker cores.
 116
 117 .. code-block:: console
 118
 119         Signal 2 received, preparing to exit...
 120           worker 12 thread done. RX=4966581 TX=4966581
 121           worker 13 thread done. RX=4963329 TX=4963329
 122           worker 14 thread done. RX=4953614 TX=4953614
 123           worker 0 thread done. RX=0 TX=0
 124           worker 11 thread done. RX=4970549 TX=4970549
 125           worker 10 thread done. RX=4986391 TX=4986391
 126           worker 9 thread done. RX=4970528 TX=4970528
 127           worker 15 thread done. RX=4974087 TX=4974087
 128           worker 8 thread done. RX=4979908 TX=4979908
 129           worker 2 thread done. RX=0 TX=0
 130
 131         Port Workload distribution:
 132         worker 0 :      12.5 % (4979876 pkts)
 133         worker 1 :      12.5 % (4970497 pkts)
 134         worker 2 :      12.5 % (4986359 pkts)
 135         worker 3 :      12.5 % (4970517 pkts)
 136         worker 4 :      12.5 % (4966566 pkts)
 137         worker 5 :      12.5 % (4963297 pkts)
 138         worker 6 :      12.5 % (4953598 pkts)
 139         worker 7 :      12.5 % (4974055 pkts)
 140
 141 To get a full dump of the state of the eventdev PMD, pass the ``-D`` flag to
 142 this application. When the app is terminated using ``Ctrl+C``, the
 143 ``rte_event_dev_dump()`` function is called, resulting in a dump of the
 144 statistics that the PMD provides. The statistics provided depend on the PMD
 145 used, see the Event Device Drivers section for a list of eventdev PMDs.