rte_launch.h(3)

📦
version 25.11.3 · 9 versions
, in ubuntu resolute, ubuntu stonking

🌸 NAME 🌸

bestie, this is the manpage for rte_launch.h — it's the DPDK header that lets you yeet tasks onto other lcores 💅 (that's the "Library Functions Manual" section of the manual, for the record, so you know exactly which vibe you're in ✨).

🎀 SYNOPSIS 🎀

💖 Typedefs

typedef 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_t rte_eal_get_lcore_state (unsigned int worker_id)
int rte_eal_wait_lcore (unsigned worker_id)
void rte_eal_mp_wait_lcore (void)

✨ Detailed Description ✨

okay so the whole point of this file is: launch tasks on other lcores. That's the mission statement, no notes 🔥.

Definition in file rte_launch.h.

💅 Typedef Documentation 💅

🌸 typedef int lcore_function_t(void *)

This is literally just the definition of a remote launch function — the shape of the thing you're allowed to yeet at another core 🫶.

Definition at line 31 of file rte_launch.h.

👑 Enumeration Type Documentation 👑

⭐ enum rte_lcore_state_t

the state of an lcore, bestie — that's it, that's the enum 💖.

Enumerator

  • WAIT — waiting for new command 😴
  • RUNNING — executing command 🏃♀️

Definition at line 21 of file rte_launch.h.

⭐ enum rte_rmt_call_main_t

This one tells you whether the main core is required to execute the handler that's being launched on all logical cores 👀.

Enumerator

  • SKIP_MAIN — the lcore handler is not executed by the main core 🙈
  • CALL_MAIN — the lcore handler is executed by the main core 💪

Definition at line 73 of file rte_launch.h.

🔥 Function Documentation 🔥

💜 int rte_eal_remote_launch (lcore_function_t * f, void * arg, unsigned worker_id)

Launch a function on another lcore. iconic behaviour, truly 👑

To be executed on the MAIN lcore only.

So here's the tea: it sends a message to a worker lcore (identified by the worker_id) that is sitting in the WAIT state — and yes, that's true after the first call to rte_eal_init(). wanna check first? call rte_eal_wait_lcore(worker_id) and see 🍓.

When the remote lcore gets that message, it switches to the RUNNING state, then calls the function f with argument arg. Once it's done executing, the remote lcore switches back to WAIT state, and the return value of f is stored in a local variable so you can read it later with rte_eal_wait_lcore() 💖.

The MAIN lcore returns the second the message is sent — it knows absolutely nothing about whether f finished 😭.

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. (she's convenient, not fast, and she's at peace with that 💅)

Parameters

  • f — 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 💀

💜 int rte_eal_mp_remote_launch (lcore_function_t * f, void * arg, enum rte_rmt_call_main_t call_main)

Launch a function on all lcores. all of them. every single one. no lcore left behind 🫶

It checks that each WORKER lcore is in a WAIT state, then calls rte_eal_remote_launch() for each lcore 🌈.

Parameters

  • f — The function to be called.
  • arg — The argument for the function.
  • call_main — If call_main is 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 😱 (all-or-nothing, periodt)

💜 enum rte_lcore_state_t rte_eal_get_lcore_state (unsigned int worker_id)

Get the state of the lcore identified by worker_id. vibe check for a core, basically 🌸

To be executed on the MAIN lcore only.

Parameters

  • worker_id — The identifier of the lcore.

Returns

The state of the lcore 👀

💜 int rte_eal_wait_lcore (unsigned worker_id)

Wait until an lcore finishes its job. patient main character energy ✨

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

Parameters

  • worker_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 🎀

💜 void rte_eal_mp_wait_lcore (void )

Wait until all lcores finish their jobs. the group hangout version 💖

To be executed on the MAIN lcore only. It issues an rte_eal_wait_lcore() for every lcore. The return values are ignored — she's not reading the receipts, she's just waiting 🙈.

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

🌟 Author 🌟

Generated automatically by Doxygen for DPDK from the source code. (not a human, just a robot doing her little thing 🤖✨)

okay bestie that's the whole page, no cap 🫶 this was DPDK, Version 25.11.3, and it's rte_launch.h(3) — go forth and launch responsibly, mwah 💅💖

📦 where this page comes from