d/numam-dpdk
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

eal: remove FINISHED lcore state

Browse Source 
FINISHED state seems to be used to indicate that the worker's update
of the 'state' is not visible to other threads. There seems to be no
requirement to have such a state.

Since the FINISHED state is removed, the API rte_eal_wait_lcore
is updated to always return the status of the last function that
ran in the worker core.

Signed-off-by: Honnappa Nagarahalli <honnappa.nagarahalli@arm.com>
Reviewed-by: Ola Liljedahl <ola.liljedahl@arm.com>
Reviewed-by: Feifei Wang <feifei.wang2@arm.com>
This commit is contained in:
Honnappa Nagarahalli 2021-10-24 23:52:35 -05:00 committed by David Marchand
parent 33969e9c61
commit f6c6c686f1
12 changed files with 28 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
doc/guides/rel_notes/deprecation.rst
View File

@ -17,10 +17,6 @@ Deprecation Notices
* eal: The function ``rte_eal_remote_launch`` will return new error codes
after read or write error on the pipe, instead of calling ``rte_panic``.
* eal: The lcore state ``FINISHED`` will be removed from
the ``enum rte_lcore_state_t``.
The lcore state ``WAIT`` is enough to represent the same state.
* eal: Making ``struct rte_intr_handle`` internal to avoid any ABI breakages
in future.

4
doc/guides/rel_notes/release_21_11.rst
View File

@ -363,6 +363,10 @@ API Changes
Also, make sure to start the actual text at the margin.
=======================================================
* eal: The lcore state ``FINISHED`` is removed from
the ``enum rte_lcore_state_t``.
The lcore state ``WAIT`` is enough to represent the same state.
* kvargs: The experimental function ``rte_kvargs_strcmp()`` has been
removed. Its usages have been replaced by a new function
``rte_kvargs_get_with_value()``.

2
drivers/event/dpaa2/dpaa2_eventdev_selftest.c
View File

@ -468,7 +468,7 @@ wait_workers_to_join(int lcore, const rte_atomic32_t *count)
RTE_SET_USED(count);
print_cycles = cycles = rte_get_timer_cycles();
while (rte_eal_get_lcore_state(lcore) != FINISHED) {
while (rte_eal_get_lcore_state(lcore) != WAIT) {
uint64_t new_cycles = rte_get_timer_cycles();
if (new_cycles - print_cycles > rte_get_timer_hz()) {

2
drivers/event/octeontx/ssovf_evdev_selftest.c
View File

@ -579,7 +579,7 @@ wait_workers_to_join(int lcore, const rte_atomic32_t *count)
RTE_SET_USED(count);
print_cycles = cycles = rte_get_timer_cycles();
while (rte_eal_get_lcore_state(lcore) != FINISHED) {
while (rte_eal_get_lcore_state(lcore) != WAIT) {
uint64_t new_cycles = rte_get_timer_cycles();
if (new_cycles - print_cycles > rte_get_timer_hz()) {

4
drivers/event/sw/sw_evdev_selftest.c
View File

@ -3140,8 +3140,8 @@ worker_loopback(struct test *t, uint8_t disable_implicit_release)
rte_eal_remote_launch(worker_loopback_worker_fn, t, w_lcore);
print_cycles = cycles = rte_get_timer_cycles();
while (rte_eal_get_lcore_state(p_lcore) != FINISHED ||
rte_eal_get_lcore_state(w_lcore) != FINISHED) {
while (rte_eal_get_lcore_state(p_lcore) != WAIT ||
rte_eal_get_lcore_state(w_lcore) != WAIT) {
rte_service_run_iter_on_app_lcore(t->service_id, 1);

3
examples/l2fwd-keepalive/main.c
View File

@ -506,8 +506,7 @@ dead_core(__rte_unused void *ptr_data, const int id_core)
if (terminate_signal_received)
return;
printf("Dead core %i - restarting..\n", id_core);
if (rte_eal_get_lcore_state(id_core) == FINISHED) {
rte_eal_wait_lcore(id_core);
if (rte_eal_get_lcore_state(id_core) == WAIT) {
rte_eal_remote_launch(l2fwd_launch_one_lcore, NULL, id_core);
} else {
printf("..false positive!\n");

7
lib/eal/common/eal_common_launch.c
View File

@ -26,14 +26,11 @@ rte_eal_wait_lcore(unsigned worker_id)
if (lcore_config[worker_id].state == WAIT)
return 0;
while (lcore_config[worker_id].state != WAIT &&
lcore_config[worker_id].state != FINISHED)
while (lcore_config[worker_id].state != WAIT)
rte_pause();
rte_rmb();
/* we are in finished state, go to wait state */
lcore_config[worker_id].state = WAIT;
return lcore_config[worker_id].ret;
}
@ -62,7 +59,7 @@ rte_eal_mp_remote_launch(int (*f)(void *), void *arg,
if (call_main == CALL_MAIN) {
lcore_config[main_lcore].ret = f(arg);
lcore_config[main_lcore].state = FINISHED;
lcore_config[main_lcore].state = WAIT;
}
return 0;

4
lib/eal/freebsd/eal_thread.c
View File

@ -28,7 +28,7 @@
/*
* Send a message to a worker lcore identified by worker_id to call a
* function f with argument arg. Once the execution is done, the
* remote lcore switch in FINISHED state.
* remote lcore switches to WAIT state.
*/
int
rte_eal_remote_launch(int (*f)(void *), void *arg, unsigned worker_id)
@ -129,7 +129,7 @@ eal_thread_loop(__rte_unused void *arg)
lcore_config[lcore_id].f = NULL;
lcore_config[lcore_id].arg = NULL;
rte_wmb();
lcore_config[lcore_id].state = FINISHED;
lcore_config[lcore_id].state = WAIT;
}
/* never reached */

21
lib/eal/include/rte_launch.h
View File

@ -19,9 +19,10 @@ extern "C" {
* State of an lcore.
*/
enum rte_lcore_state_t {
WAIT, /**< waiting a new command */
RUNNING, /**< executing command */
FINISHED, /**< command executed */
WAIT,
/**< waiting for new command */
RUNNING,
/**< executing command */
};
/**
@ -41,7 +42,7 @@ typedef int (lcore_function_t)(void *);
*
* When the remote lcore receives the message, it switches to
* the RUNNING state, then calls the function f with argument arg. Once the
* execution is done, the remote lcore switches to a FINISHED state and
* execution is done, the remote lcore switches to WAIT state and
* the return value of f is stored in a local variable to be read using
* rte_eal_wait_lcore().
*
@ -114,18 +115,16 @@ enum rte_lcore_state_t rte_eal_get_lcore_state(unsigned int worker_id);
*
* To be executed on the MAIN lcore only.
*
* If the worker lcore identified by the worker_id is in a FINISHED state,
* switch to the WAIT state. If the lcore is in RUNNING state, wait until
* the lcore finishes its job and moves to the FINISHED state.
* If the lcore identified by the worker_id is in RUNNING state, wait until
* the lcore finishes its job and moves to the WAIT state.
*
* @param worker_id
* The identifier of the lcore.
* @return
* - 0: If the lcore identified by the worker_id is in a WAIT state.
* - 0: If the remote launch function was never called on the lcore
* identified by the worker_id.
* - The value that was returned by the previous remote launch
* function call if the lcore identified by the worker_id was in a
* FINISHED or RUNNING state. In this case, it changes the state
* of the lcore to WAIT.
* function call.
*/
int rte_eal_wait_lcore(unsigned worker_id);

4
lib/eal/include/rte_service.h
View File

@ -320,9 +320,7 @@ int32_t rte_service_lcore_count(void);
* from duty, just unmaps all services / cores, and stops() the service cores.
* The runstate of services is not modified.
*
* The cores that are stopped with this call, are in FINISHED state and
* the application must take care of bringing them back to a launchable state:
* e.g. call *rte_eal_lcore_wait* on the lcore_id.
* The cores that are stopped with this call, are in WAIT state.
*
* @retval 0 Success
*/

10
lib/eal/linux/eal_thread.c
View File

@ -28,7 +28,7 @@
/*
* Send a message to a worker lcore identified by worker_id to call a
* function f with argument arg. Once the execution is done, the
* remote lcore switch in FINISHED state.
* remote lcore switches to WAIT state.
*/
int
rte_eal_remote_launch(int (*f)(void *), void *arg, unsigned int worker_id)
@ -130,13 +130,7 @@ eal_thread_loop(__rte_unused void *arg)
lcore_config[lcore_id].arg = NULL;
rte_wmb();
/* when a service core returns, it should go directly to WAIT
* state, because the application will not lcore_wait() for it.
*/
if (lcore_config[lcore_id].core_role == ROLE_SERVICE)
lcore_config[lcore_id].state = WAIT;
else
lcore_config[lcore_id].state = FINISHED;
lcore_config[lcore_id].state = WAIT;
}
/* never reached */

10
lib/eal/windows/eal_thread.c
View File

@ -19,7 +19,7 @@
/*
* Send a message to a worker lcore identified by worker_id to call a
* function f with argument arg. Once the execution is done, the
* remote lcore switch in FINISHED state.
* remote lcore switches to WAIT state.
*/
int
rte_eal_remote_launch(lcore_function_t *f, void *arg, unsigned int worker_id)
@ -114,13 +114,7 @@ eal_thread_loop(void *arg __rte_unused)
lcore_config[lcore_id].arg = NULL;
rte_wmb();
/* when a service core returns, it should go directly to WAIT
* state, because the application will not lcore_wait() for it.
*/
if (lcore_config[lcore_id].core_role == ROLE_SERVICE)
lcore_config[lcore_id].state = WAIT;
else
lcore_config[lcore_id].state = FINISHED;
lcore_config[lcore_id].state = WAIT;
}
}