rte_launch.h

       Generated automatically by Doxygen for DPDK from the source code.

DPDK                                             Version 24.11.2                                 rte_launch.h(3)

       Launch tasks on other lcores

       Definition in file rte_launch.h.

enumrte_lcore_state_t
       State of an lcore.

       EnumeratorWAIT   waiting for new command

       RUNNING
              executing command

       Definition at line 21 of file rte_launch.h.

   enumrte_rmt_call_main_t
       This enum indicates whether the main core must execute the handler launched on all logical cores.

       EnumeratorSKIP_MAIN
              lcore handler not executed by main core.

       CALL_MAIN
              lcore handler executed by main core.

       Definition at line 73 of file rte_launch.h.

intrte_eal_remote_launch(lcore_function_t*f,void*arg,unsignedworker_id)
       Launch a function on another lcore.

       To be executed on the MAIN lcore only.

       Sends  a  message to a worker lcore (identified by the worker_id) that is in the WAIT state (this is true
       after   the   first   call   to   rte_eal_init()).   This   can   be    checked    by    first    calling
       rte_eal_wait_lcore(worker_id).

       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 WAIT  state  and  the  return
       value of f is stored in a local variable to be read using rte_eal_wait_lcore().

       The MAIN lcore returns as soon as the message is sent and knows nothing about the completion of f.

       Note:  This function is not designed to offer optimum performance. It is just a practical way to launch a
       function on another lcore at initialization time.

       Parametersf The function to be called.
           arg The argument for the function.
           worker_id The identifier of the lcore on which the function should be executed.

       Returns

           • 0: Success. Execution of function f started on the remote lcore.

           • (-EBUSY): The remote lcore is not in a WAIT state.

           • (-EPIPE): Error reading or writing pipe to worker thread

   intrte_eal_mp_remote_launch(lcore_function_t*f,void*arg,enumrte_rmt_call_main_tcall_main)
       Launch a function on all lcores.

       Check that each WORKER lcore is in a WAIT state, then call rte_eal_remote_launch() for each lcore.

       Parametersf The function to be called.
           arg The argument for the function.
           call_main If call_main set to SKIP_MAIN, the MAIN lcore does not call the function. If  call_main  is
           set  to  CALL_MAIN, the function is also called on main before returning. In any case, the main lcore
           returns as soon as it finished its job and knows nothing about the  completion  of  f  on  the  other
           lcores.

       Returns

           • 0: Success. Execution of function f started on all remote lcores.

           • (-EBUSY): At least one remote lcore is not in a WAIT state. In this case, no message is sent to any
             of the lcores.

   enumrte_lcore_state_trte_eal_get_lcore_state(unsignedintworker_id)
       Get the state of the lcore identified by worker_id.

       To be executed on the MAIN lcore only.

       Parametersworker_id The identifier of the lcore.

       Returns
           The state of the lcore.

   intrte_eal_wait_lcore(unsignedworker_id)
       Wait until an lcore finishes its job.

       To be executed on the MAIN lcore only.

       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.

       Parametersworker_id The identifier of the lcore.

       Returns

           • 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.

   voidrte_eal_mp_wait_lcore(void)
       Wait until all lcores finish their jobs.

       To be executed on the MAIN lcore only. Issue an rte_eal_wait_lcore() for every lcore. The  return  values
       are ignored.

       After  a  call  to  rte_eal_mp_wait_lcore(),  the  caller can assume that all worker lcores are in a WAIT
       state.

       rte_launch.h

Typedefstypedef int() lcore_function_t(void *)

   Enumerations
       enum rte_lcore_state_t { WAIT, RUNNING }
       enum rte_rmt_call_main_t { SKIP_MAIN = 0, CALL_MAIN }

   Functions
       int rte_eal_remote_launch (lcore_function_t *f, void *arg, unsigned worker_id)
       int rte_eal_mp_remote_launch (lcore_function_t *f, void *arg, enum rte_rmt_call_main_t call_main)
       enum rte_lcore_state_trte_eal_get_lcore_state (unsigned int worker_id)
       int rte_eal_wait_lcore (unsigned worker_id)
       void rte_eal_mp_wait_lcore (void)

typedefint()lcore_function_t(void*)
       Definition of a remote launch function.

       Definition at line 31 of file rte_launch.h.