Download Sample Applications User Guide

Sample Applications User Guide, Release 2.0.0
same port for reception and forwarding; they could use lock structures to do exclusive access
in some critical path. What happens to the dependent process(es) if the peer leaves? The
consequence are varied since the dependency cases are complex. It depends on what the
processed had shared. However, it is necessary to notify the peer(s) if one slave exited. Then,
the peer(s) will be aware of that and wait until the new instance begins to run.
Therefore, to provide the capability to resume the new slave instance if the previous one exited,
it is necessary to provide several mechanisms:
1. Keep a resource list for each slave process. Before a slave process run, the master
should prepare a resource list. After it exits, the master could either delete the allocated
resources and create new ones, or re-initialize those for use by the new instance.
2. Set up a notification mechanism for slave process exit cases. After the specific slave
leaves, the master should be notified and then help to create a new instance. This mechanism is provided in Section Master-slave Process Models.
3. Use a synchronization mechanism among dependent processes. The master should
have the capability to stop or kill slave processes that have a dependency on the one
that has exited. Then, after the new instance of exited slave process begins to run,
the dependency ones could resume or run from the start. The example sends a STOP
command to slave processes dependent on the exited one, then they will exit. Thereafter,
the master creates new instances for the exited slave processes.
The following diagram describes slave process recovery.
Figure 19.4: Slave Process Recovery Process Flow
Floating Process Support
When the DPDK application runs, there is always a -c option passed in to indicate the cores
that are enabled. Then, the DPDK creates a thread for each enabled core. By doing so, it
creates a 1:1 mapping between the enabled core and each thread. The enabled core always
has an ID, therefore, each thread has a unique core ID in the DPDK execution environment.
With the ID, each thread can easily access the structures or resources exclusively belonging
to it without using function parameter passing. It can easily use the rte_lcore_id() function to
get the value in every function that is called.
For threads/processes not created in that way, either pinned to a core or not, they will not own a
unique ID and the rte_lcore_id() function will not work in the correct way. However, sometimes
these threads/processes still need the unique ID mechanism to do easy access on structures or
resources. For example, the DPDK mempool library provides a local cache mechanism (refer
19.1. Example Applications
112