rte_bbdev_op.h(3)

📦 version 26.03, in nixos 26.05, nixpkgs unstable

🦋 rte_bbdev_op.h — Library Functions Manual 🫶

(part 1 of 3, bestie — we're going in)

📛 NAME 📛

rte_bbdev_op.h

That's literally it. The NAME section is just the header name, and honestly? Minimalist main character energy. 💅

✨ SYNOPSIS ✨

Okay so first up, the includes. Copy these exactly, no freestyling, fr fr:

#include <stdint.h>
#include <rte_compat.h>
#include <rte_common.h>
#include <rte_mbuf.h>
#include <rte_memory.h>
#include <rte_mempool.h>

🧱 Data Structures 🧱

These are the structs on deck, in the exact order the page gives them. No cap, every single one stays:

  • struct rte_bbdev_op_data
  • struct rte_bbdev_op_dec_turbo_cb_params
  • struct rte_bbdev_op_dec_ldpc_cb_params
  • struct rte_bbdev_op_dec_turbo_tb_params
  • struct rte_bbdev_op_dec_ldpc_tb_params
  • struct rte_bbdev_op_turbo_dec
  • struct rte_bbdev_op_ldpc_dec
  • struct rte_bbdev_op_enc_turbo_cb_params
  • struct rte_bbdev_op_enc_turbo_tb_params
  • struct rte_bbdev_op_enc_ldpc_cb_params
  • struct rte_bbdev_op_enc_ldpc_tb_params
  • struct rte_bbdev_op_turbo_enc
  • struct rte_bbdev_op_ldpc_enc
  • struct rte_bbdev_op_fft
  • struct rte_bbdev_op_mldts
  • struct rte_bbdev_op_cap_turbo_dec
  • struct rte_bbdev_op_cap_turbo_enc
  • struct rte_bbdev_op_cap_ldpc_dec
  • struct rte_bbdev_op_cap_ldpc_enc
  • struct rte_bbdev_op_cap_fft
  • struct rte_bbdev_op_cap_mld
  • struct rte_bbdev_enc_op
  • struct rte_bbdev_dec_op
  • struct rte_bbdev_fft_op
  • struct rte_bbdev_mldts_op
  • struct rte_bbdev_op_cap

🎚️ Enumerations 🎚️

Bestie, these bitmask enums are the whole vibe check. Every value stays exactly as written — don't @ me. 💖

enum rte_bbdev_op_td_flag_bitmasks

enum rte_bbdev_op_td_flag_bitmasks {
    RTE_BBDEV_TURBO_SUBBLOCK_DEINTERLEAVE = (1ULL << 0),
    RTE_BBDEV_TURBO_CRC_TYPE_24B = (1ULL << 1),
    RTE_BBDEV_TURBO_EQUALIZER = (1ULL << 2),
    RTE_BBDEV_TURBO_SOFT_OUT_SATURATE = (1ULL << 3),
    RTE_BBDEV_TURBO_HALF_ITERATION_EVEN = (1ULL << 4),
    RTE_BBDEV_TURBO_CONTINUE_CRC_MATCH = (1ULL << 5),
    RTE_BBDEV_TURBO_SOFT_OUTPUT = (1ULL << 6),
    RTE_BBDEV_TURBO_EARLY_TERMINATION = (1ULL << 7),
    RTE_BBDEV_TURBO_DEC_INTERRUPTS = (1ULL << 9),
    RTE_BBDEV_TURBO_POS_LLR_1_BIT_IN = (1ULL << 10),
    RTE_BBDEV_TURBO_NEG_LLR_1_BIT_IN = (1ULL << 11),
    RTE_BBDEV_TURBO_POS_LLR_1_BIT_SOFT_OUT = (1ULL << 12),
    RTE_BBDEV_TURBO_NEG_LLR_1_BIT_SOFT_OUT = (1ULL << 13),
    RTE_BBDEV_TURBO_MAP_DEC = (1ULL << 14),
    RTE_BBDEV_TURBO_DEC_SCATTER_GATHER = (1ULL << 15),
    RTE_BBDEV_TURBO_DEC_TB_CRC_24B_KEEP = (1ULL << 16),
    RTE_BBDEV_TURBO_DEC_CRC_24B_DROP = (1ULL << 17)
}

enum rte_bbdev_op_te_flag_bitmasks

enum rte_bbdev_op_te_flag_bitmasks {
    RTE_BBDEV_TURBO_RV_INDEX_BYPASS = (1ULL << 0),
    RTE_BBDEV_TURBO_RATE_MATCH = (1ULL << 1),
    RTE_BBDEV_TURBO_CRC_24B_ATTACH = (1ULL << 2),
    RTE_BBDEV_TURBO_CRC_24A_ATTACH = (1ULL << 3),
    RTE_BBDEV_TURBO_ENC_INTERRUPTS = (1ULL << 4),
    RTE_BBDEV_TURBO_ENC_SCATTER_GATHER = (1ULL << 5)
}

enum rte_bbdev_op_ldpcdec_flag_bitmasks

enum rte_bbdev_op_ldpcdec_flag_bitmasks {
    RTE_BBDEV_LDPC_CRC_TYPE_24A_CHECK = (1ULL << 0),
    RTE_BBDEV_LDPC_CRC_TYPE_24B_CHECK = (1ULL << 1),
    RTE_BBDEV_LDPC_CRC_TYPE_24B_DROP = (1ULL << 2),
    RTE_BBDEV_LDPC_CRC_TYPE_16_CHECK = (1ULL << 3),
    RTE_BBDEV_LDPC_DEINTERLEAVER_BYPASS = (1ULL << 4),
    RTE_BBDEV_LDPC_HQ_COMBINE_IN_ENABLE = (1ULL << 5),
    RTE_BBDEV_LDPC_HQ_COMBINE_OUT_ENABLE = (1ULL << 6),
    RTE_BBDEV_LDPC_DECODE_BYPASS = (1ULL << 7),
    RTE_BBDEV_LDPC_SOFT_OUT_ENABLE = (1ULL << 8),
    RTE_BBDEV_LDPC_SOFT_OUT_RM_BYPASS = (1ULL << 9),
    RTE_BBDEV_LDPC_SOFT_OUT_DEINTERLEAVER_BYPASS = (1ULL << 10),
    RTE_BBDEV_LDPC_ITERATION_STOP_ENABLE = (1ULL << 11),
    RTE_BBDEV_LDPC_DEC_INTERRUPTS = (1ULL << 12),
    RTE_BBDEV_LDPC_DEC_SCATTER_GATHER = (1ULL << 13),
    RTE_BBDEV_LDPC_HARQ_6BIT_COMPRESSION = (1ULL << 14),
    RTE_BBDEV_LDPC_LLR_COMPRESSION = (1ULL << 15),
    RTE_BBDEV_LDPC_INTERNAL_HARQ_MEMORY_IN_ENABLE = (1ULL << 16),
    RTE_BBDEV_LDPC_INTERNAL_HARQ_MEMORY_OUT_ENABLE = (1ULL << 17),
    RTE_BBDEV_LDPC_INTERNAL_HARQ_MEMORY_LOOPBACK = (1ULL << 18),
    RTE_BBDEV_LDPC_INTERNAL_HARQ_MEMORY_FILLERS = (1ULL << 19),
    RTE_BBDEV_LDPC_HARQ_4BIT_COMPRESSION = (1ULL << 20)
}

enum rte_bbdev_op_ldpcenc_flag_bitmasks

enum rte_bbdev_op_ldpcenc_flag_bitmasks {
    RTE_BBDEV_LDPC_INTERLEAVER_BYPASS = (1ULL << 0),
    RTE_BBDEV_LDPC_RATE_MATCH = (1ULL << 1),
    RTE_BBDEV_LDPC_CRC_24A_ATTACH = (1ULL << 2),
    RTE_BBDEV_LDPC_CRC_24B_ATTACH = (1ULL << 3),
    RTE_BBDEV_LDPC_CRC_16_ATTACH = (1ULL << 4),
    RTE_BBDEV_LDPC_ENC_INTERRUPTS = (1ULL << 5),
    RTE_BBDEV_LDPC_ENC_SCATTER_GATHER = (1ULL << 6),
    RTE_BBDEV_LDPC_ENC_CONCATENATION = (1ULL << 7)
}

enum rte_bbdev_op_fft_flag_bitmasks

enum rte_bbdev_op_fft_flag_bitmasks {
    RTE_BBDEV_FFT_WINDOWING = (1ULL << 0),
    RTE_BBDEV_FFT_CS_ADJUSTMENT = (1ULL << 1),
    RTE_BBDEV_FFT_DFT_BYPASS = (1ULL << 2),
    RTE_BBDEV_FFT_IDFT_BYPASS = (1ULL << 3),
    RTE_BBDEV_FFT_WINDOWING_BYPASS = (1ULL << 4),
    RTE_BBDEV_FFT_POWER_MEAS = (1ULL << 5),
    RTE_BBDEV_FFT_FP16_INPUT = (1ULL << 6),
    RTE_BBDEV_FFT_FP16_OUTPUT = (1ULL << 7),
    RTE_BBDEV_FFT_TIMING_OFFSET_PER_CS = (1ULL << 8),
    RTE_BBDEV_FFT_TIMING_ERROR = (1ULL << 9),
    RTE_BBDEV_FFT_DEWINDOWING = (1ULL << 10),
    RTE_BBDEV_FFT_FREQ_RESAMPLING = (1ULL << 11)
}

enum rte_bbdev_op_mldts_flag_bitmasks

enum rte_bbdev_op_mldts_flag_bitmasks {
    RTE_BBDEV_MLDTS_REP = (1ULL << 0)
}

enum rte_bbdev_op_cb_mode

enum rte_bbdev_op_cb_mode {
    RTE_BBDEV_TRANSPORT_BLOCK = 0,
    RTE_BBDEV_CODE_BLOCK = 1
}

enum rte_bbdev_op_type

enum rte_bbdev_op_type {
    RTE_BBDEV_OP_NONE,
    RTE_BBDEV_OP_TURBO_DEC,
    RTE_BBDEV_OP_TURBO_ENC,
    RTE_BBDEV_OP_LDPC_DEC,
    RTE_BBDEV_OP_LDPC_ENC,
    RTE_BBDEV_OP_FFT,
    RTE_BBDEV_OP_MLDTS
}

And then there's this last one:

  • enum — yes, the page literally just says enum here. No name, no values, no explanation. It's giving mysterious cliffhanger energy 😭.

🧚 Functions 🧚

Here's the declared function list, bestie. Signatures stay verbatim because we do not mess with header receipts. 💅

  • const char * rte_bbdev_op_type_str (enum rte_bbdev_op_type op_type) — exact signature, copied with love.
  • struct rte_mempool * rte_bbdev_op_pool_create (const char *name, enum rte_bbdev_op_type type, unsigned int num_elements, unsigned int cache_size, int socket_id) — same deal: verbatim, no edits.
  • static int rte_bbdev_enc_op_alloc_bulk (struct rte_mempool *mempool, struct rte_bbdev_enc_op **ops, unsigned int num_ops) — exact as listed.
  • static int rte_bbdev_dec_op_alloc_bulk (struct rte_mempool *mempool, struct rte_bbdev_dec_op **ops, unsigned int num_ops) — exact as listed.
  • static int rte_bbdev_fft_op_alloc_bulk (struct rte_mempool *mempool, struct rte_bbdev_fft_op **ops, unsigned int num_ops) — exact as listed.
  • static int rte_bbdev_mldts_op_alloc_bulk (struct rte_mempool *mempool, struct rte_bbdev_mldts_op **ops, uint16_t num_ops) — yep, uint16_t num_ops here, not unsigned int. Keep that detail. 🫶
  • static void rte_bbdev_dec_op_free_bulk (struct rte_bbdev_dec_op **ops, unsigned int num_ops) — exact as listed.
  • static void rte_bbdev_enc_op_free_bulk (struct rte_bbdev_enc_op **ops, unsigned int num_ops) — exact as listed.
  • static void rte_bbdev_fft_op_free_bulk (struct rte_bbdev_fft_op **ops, unsigned int num_ops) — exact as listed.
  • static void rte_bbdev_mldts_op_free_bulk (struct rte_bbdev_mldts_op **ops, unsigned int num_ops) — exact as listed.

💖 Detailed Description 💖

Defines wireless base band layer 1 operations and capabilities.

Definition in file rte_bbdev_op.h.

✨ Enumeration Type Documentation ✨

enum rte_bbdev_op_td_flag_bitmasks

Okay bestie, these are the flags for the turbo decoder operation and capability structure 💅 — every single one matters, so here’s the whole lineup:

  • RTE_BBDEV_TURBO_SUBBLOCK_DEINTERLEAVE — set this if sub block de-interleaving is to be performed.
  • RTE_BBDEV_TURBO_CRC_TYPE_24B — use CRC Type 24B; otherwise it’s CRC Type 24A.
  • RTE_BBDEV_TURBO_EQUALIZER — set this if turbo equalization is to be performed.
  • RTE_BBDEV_TURBO_SOFT_OUT_SATURATE — if set, saturate soft output to +/-127.
  • RTE_BBDEV_TURBO_HALF_ITERATION_EVEN — set to 1 to start iteration from even, else odd; one iteration = max_iteration + 0.5.
  • RTE_BBDEV_TURBO_CONTINUE_CRC_MATCH — if 0, TD stops after CRC matches; else if 1, it runs to the end of the next odd iteration after CRC matches.
  • RTE_BBDEV_TURBO_SOFT_OUTPUT — set if soft output is required to be output.
  • RTE_BBDEV_TURBO_EARLY_TERMINATION — set to enable early termination mode.
  • RTE_BBDEV_TURBO_DEC_INTERRUPTS — set if a device supports decoder dequeue interrupts.
  • RTE_BBDEV_TURBO_POS_LLR_1_BIT_IN — set if positive LLR encoded input is supported. Positive LLR value represents the level of confidence for bit '1', and vice versa for bit '0'. This is mutually exclusive with RTE_BBDEV_TURBO_NEG_LLR_1_BIT_IN when used to formalize the input data format.
  • RTE_BBDEV_TURBO_NEG_LLR_1_BIT_IN — set if negative LLR encoded input is supported. Negative LLR value represents the level of confidence for bit '1', and vice versa for bit '0'. This is mutually exclusive with RTE_BBDEV_TURBO_POS_LLR_1_BIT_IN when used to formalize the input data format.
  • RTE_BBDEV_TURBO_POS_LLR_1_BIT_SOFT_OUT — set if positive LLR soft output is supported. Positive LLR value represents the level of confidence for bit '1', and vice versa for bit '0'. This is mutually exclusive with RTE_BBDEV_TURBO_NEG_LLR_1_BIT_SOFT_OUT when used to formalize the input data format.
  • RTE_BBDEV_TURBO_NEG_LLR_1_BIT_SOFT_OUT — set if negative LLR soft output is supported. Negative LLR value represents the level of confidence for bit '1', and vice versa for bit '0'. This is mutually exclusive with RTE_BBDEV_TURBO_POS_LLR_1_BIT_SOFT_OUT when used to formalize the input data format.
  • RTE_BBDEV_TURBO_MAP_DEC — set if the driver supports flexible parallel MAP engine decoding. If it’s not supported, the num_maps (number of MAP engines) argument is unusable.
  • RTE_BBDEV_TURBO_DEC_SCATTER_GATHER — set if a device supports scatter-gather functionality.
  • RTE_BBDEV_TURBO_DEC_TB_CRC_24B_KEEP — set to keep CRC24B bits appended while decoding. Only usable when decoding Transport Block mode.
  • RTE_BBDEV_TURBO_DEC_CRC_24B_DROP — set to drop CRC24B bits not to be appended while decoding.

Definition at line 67 of file rte_bbdev_op.h.

enum rte_bbdev_op_te_flag_bitmasks

These are the flags for the turbo encoder operation and capability structure ✨ — short list, but every bit is doing its job:

  • RTE_BBDEV_TURBO_RV_INDEX_BYPASS — ignore rv_index and set K0 = 0.
  • RTE_BBDEV_TURBO_RATE_MATCH — set if rate matching is to be performed.
  • RTE_BBDEV_TURBO_CRC_24B_ATTACH — this bit must be set to enable CRC-24B generation.
  • RTE_BBDEV_TURBO_CRC_24A_ATTACH — this bit must be set to enable CRC-24A generation.
  • RTE_BBDEV_TURBO_ENC_INTERRUPTS — set if a device supports encoder dequeue interrupts.
  • RTE_BBDEV_TURBO_ENC_SCATTER_GATHER — set if a device supports scatter-gather functionality.

Definition at line 137 of file rte_bbdev_op.h.

enum rte_bbdev_op_ldpcdec_flag_bitmasks

LDPC decoder flags, bestie 🦋 — this is the big one, so stay with me:

  • RTE_BBDEV_LDPC_CRC_TYPE_24A_CHECK — set for transport block CRC-24A checking.
  • RTE_BBDEV_LDPC_CRC_TYPE_24B_CHECK — set for code block CRC-24B checking.
  • RTE_BBDEV_LDPC_CRC_TYPE_24B_DROP — set to drop the last CRC bits decoding output.
  • RTE_BBDEV_LDPC_CRC_TYPE_16_CHECK — set for transport block CRC-16 checking.
  • RTE_BBDEV_LDPC_DEINTERLEAVER_BYPASS — set for bit-level de-interleaver bypass on Rx stream.
  • RTE_BBDEV_LDPC_HQ_COMBINE_IN_ENABLE — set for HARQ combined input stream enable.
  • RTE_BBDEV_LDPC_HQ_COMBINE_OUT_ENABLE — set for HARQ combined output stream enable.
  • RTE_BBDEV_LDPC_DECODE_BYPASS — set for LDPC decoder bypass. RTE_BBDEV_LDPC_HQ_COMBINE_OUT_ENABLE must be set.
  • RTE_BBDEV_LDPC_SOFT_OUT_ENABLE — set for soft-output stream enable.
  • RTE_BBDEV_LDPC_SOFT_OUT_RM_BYPASS — set for Rate-Matching bypass on soft-out stream.
  • RTE_BBDEV_LDPC_SOFT_OUT_DEINTERLEAVER_BYPASS — set for bit-level de-interleaver bypass on soft-output stream.
  • RTE_BBDEV_LDPC_ITERATION_STOP_ENABLE — set for iteration stopping on successful decode condition, i.e. a successful syndrome check.
  • RTE_BBDEV_LDPC_DEC_INTERRUPTS — set if a device supports decoder dequeue interrupts.
  • RTE_BBDEV_LDPC_DEC_SCATTER_GATHER — set if a device supports scatter-gather functionality.
  • RTE_BBDEV_LDPC_HARQ_6BIT_COMPRESSION — set if a device supports input/output HARQ compression.
  • RTE_BBDEV_LDPC_LLR_COMPRESSION — set if a device supports input LLR compression.
  • RTE_BBDEV_LDPC_INTERNAL_HARQ_MEMORY_IN_ENABLE — set if a device supports HARQ input from the device’s internal memory.
  • RTE_BBDEV_LDPC_INTERNAL_HARQ_MEMORY_OUT_ENABLE — set if a device supports HARQ output to the device’s internal memory.
  • RTE_BBDEV_LDPC_INTERNAL_HARQ_MEMORY_LOOPBACK — set if a device supports loop-back access to HARQ internal memory. Intended for troubleshooting.
  • RTE_BBDEV_LDPC_INTERNAL_HARQ_MEMORY_FILLERS — set if a device includes LLR filler bits in the circular buffer for HARQ memory. If not set, it is assumed the filler bits are not in HARQ memory and handled directly by the LDPC decoder.
  • RTE_BBDEV_LDPC_HARQ_4BIT_COMPRESSION — set if a device supports input/output HARQ 4bits compression.

Definition at line 153 of file rte_bbdev_op.h.

enum rte_bbdev_op_ldpcenc_flag_bitmasks

LDPC encoder flags incoming 🎀 — yes, they’re giving capability-structure realness:

  • RTE_BBDEV_LDPC_INTERLEAVER_BYPASS — set for bit-level interleaver bypass on output stream.
  • RTE_BBDEV_LDPC_RATE_MATCH — set if rate matching is to be performed.
  • RTE_BBDEV_LDPC_CRC_24A_ATTACH — set for transport block CRC-24A attach.
  • RTE_BBDEV_LDPC_CRC_24B_ATTACH — set for code block CRC-24B attach.
  • RTE_BBDEV_LDPC_CRC_16_ATTACH — set for code block CRC-16 attach.
  • RTE_BBDEV_LDPC_ENC_INTERRUPTS — set if a device supports encoder dequeue interrupts.
  • RTE_BBDEV_LDPC_ENC_SCATTER_GATHER — set if a device supports scatter-gather functionality.
  • RTE_BBDEV_LDPC_ENC_CONCATENATION — set if a device supports concatenation of non byte aligned output.

Definition at line 212 of file rte_bbdev_op.h.

enum rte_bbdev_op_fft_flag_bitmasks

FFT flags, and yes, the vibes are flexible 🌈 — here’s every one:

  • RTE_BBDEV_FFT_WINDOWING — flexible windowing capability.
  • RTE_BBDEV_FFT_CS_ADJUSTMENT — flexible adjustment of Cyclic Shift time offset.
  • RTE_BBDEV_FFT_DFT_BYPASS — set for bypass the DFT and get directly into iDFT input.
  • RTE_BBDEV_FFT_IDFT_BYPASS — set for bypass the IDFT and get directly the DFT output.
  • RTE_BBDEV_FFT_WINDOWING_BYPASS — set for bypass time domain windowing.
  • RTE_BBDEV_FFT_POWER_MEAS — set for optional power measurement on DFT output.
  • RTE_BBDEV_FFT_FP16_INPUT — set if the input data used FP16 format.
  • RTE_BBDEV_FFT_FP16_OUTPUT — set if the output data uses FP16 format.
  • RTE_BBDEV_FFT_TIMING_OFFSET_PER_CS — flexible adjustment of Timing offset adjustment per CS.
  • RTE_BBDEV_FFT_TIMING_ERROR — flexible adjustment of Timing error correction per CS.
  • RTE_BBDEV_FFT_DEWINDOWING — set for optional frequency domain dewindowing.
  • RTE_BBDEV_FFT_FREQ_RESAMPLING — flexible adjustment of frequency resampling mode.

Definition at line 232 of file rte_bbdev_op.h.

enum rte_bbdev_op_mldts_flag_bitmasks

MLDTS flags — tiny but iconic 💜:

  • RTE_BBDEV_MLDTS_REP — set if the device supports C/R repetition options.

Definition at line 260 of file rte_bbdev_op.h.

enum rte_bbdev_op_cb_mode

These are the flags for the Code Block/Transport block mode, bestie 🫶:

  • RTE_BBDEV_TRANSPORT_BLOCK — one operation is one or fraction of one transport block.
  • RTE_BBDEV_CODE_BLOCK — one operation is one code block mode.

Definition at line 266 of file rte_bbdev_op.h.

enum rte_bbdev_op_type

Different operation types supported by the device. The related macro RTE_BBDEV_OP_TYPE_SIZE_MAX can be used as an absolute maximum for notably sizing array while allowing for future enumeration insertion. No cap, the enum is ready to grow 😌:

  • RTE_BBDEV_OP_NONE — dummy operation that does nothing.
  • RTE_BBDEV_OP_TURBO_DEC — Turbo decode.
  • RTE_BBDEV_OP_TURBO_ENC — Turbo encode.
  • RTE_BBDEV_OP_LDPC_DEC — LDPC decode.
  • RTE_BBDEV_OP_LDPC_ENC — LDPC encode.
  • RTE_BBDEV_OP_FFT — FFT.
  • RTE_BBDEV_OP_MLDTS — MLD-TS.

Definition at line 930 of file rte_bbdev_op.h.

anonymous enum

Bit indexes of possible errors reported through status field 🔥.

Definition at line 942 of file rte_bbdev_op.h.

💜 FUNCTION DOCUMENTATION 💜

okay bestie, this is the part where we actually call stuff. all the helper functions, laid out like a little function runway. let's go 🎀

🌸 rte_bbdev_op_type_str

const char * rte_bbdev_op_type_str (enum rte_bbdev_op_type op_type)

Converts a queue operation type from its enum form into a string. literally enum-to-string glow-up ✨

Parameters

  • op_type — the operation type, as an enum

Returns

The operation type as a string, or NULL if op_type is invalid. so if you get NULL back, that's your vibe check failing 🙈

🦋 rte_bbdev_op_pool_create

struct rte_mempool * rte_bbdev_op_pool_create (const char * name, enum rte_bbdev_op_type type, unsigned int num_elements, unsigned int cache_size, int socket_id)

Creates a bbdev operation mempool. this is the main character function of the whole allocation saga — everything else builds on the pool you make here 👑

Parameters

  • name — pool name.
  • type — operation type. use RTE_BBDEV_OP_NONE for a pool which supports all operation types. no cap, that's the flexible one 💅
  • num_elements — number of elements in the pool.
  • cache_size — number of elements to cache on an lcore. see rte_mempool_create() for further details about cache size. (yes bestie, go read that one too, it's the lore 🫶)
  • socket_id — socket to allocate memory on.

Returns

  • Pointer to a mempool on success,
  • NULL pointer on failure.

so check for that NULL, fr fr 😭

🎀 rte_bbdev_enc_op_alloc_bulk

int rte_bbdev_enc_op_alloc_bulk (struct rte_mempool * mempool, struct rte_bbdev_enc_op ** ops, unsigned int num_ops)

[inline], [static]

Bulk allocate encode operations from a mempool, with parameter defaults reset. bulk = grab a whole handful at once, it's giving efficiency 🌈

Parameters

  • mempool — operation mempool, created by rte_bbdev_op_pool_create().
  • ops — output array to place allocated operations
  • num_ops — number of operations to allocate

Returns

  • 0 on success
  • EINVAL if invalid mempool is provided
Definition at line 1076 of file rte_bbdev_op.h.

💖 rte_bbdev_dec_op_alloc_bulk

int rte_bbdev_dec_op_alloc_bulk (struct rte_mempool * mempool, struct rte_bbdev_dec_op ** ops, unsigned int num_ops)

[inline], [static]

Bulk allocate decode operations from a mempool, with parameter defaults reset. same energy as the encode one, just decode flavored 💫

Parameters

  • mempool — operation mempool, created by rte_bbdev_op_pool_create().
  • ops — output array to place allocated operations
  • num_ops — number of operations to allocate

Returns

  • 0 on success
  • EINVAL if invalid mempool is provided
Definition at line 1107 of file rte_bbdev_op.h.

🧚 rte_bbdev_fft_op_alloc_bulk

int rte_bbdev_fft_op_alloc_bulk (struct rte_mempool * mempool, struct rte_bbdev_fft_op ** ops, unsigned int num_ops)

[inline], [static]

Bulk allocate FFT operations from a mempool, with default parameters. FFT said lemme in on the bulk action 🔥

Parameters

  • mempool — operation mempool, created by rte_bbdev_op_pool_create.
  • ops — output array to place allocated operations.
  • num_ops — number of operations to allocate.

Returns

  • 0 on success.
  • EINVAL if invalid mempool is provided.
Definition at line 1138 of file rte_bbdev_op.h.

⭐ rte_bbdev_mldts_op_alloc_bulk

int rte_bbdev_mldts_op_alloc_bulk (struct rte_mempool * mempool, struct rte_bbdev_mldts_op ** ops, uint16_t num_ops)

[inline], [static]

Bulk allocate MLD operations from a mempool, with parameter defaults reset. and yes bestie, clock it: num_ops here is a uint16_t, not an unsigned int like the others 👀 don't get caught slippin'

Parameters

  • mempool — operation mempool, created by rte_bbdev_op_pool_create.
  • ops — output array to place allocated operations.
  • num_ops — number of operations to allocate.

Returns

  • 0 on success.
  • EINVAL if invalid mempool is provided.
Definition at line 1167 of file rte_bbdev_op.h.

🌸 rte_bbdev_dec_op_free_bulk

void rte_bbdev_dec_op_free_bulk (struct rte_bbdev_dec_op ** ops, unsigned int num_ops)

[inline], [static]

Free decode operation structures that were allocated by rte_bbdev_dec_op_alloc_bulk(). All structures must belong to the same mempool — that part is not optional, so keep your ops together like a little friend group 🫶

Parameters

  • ops — operation structures
  • num_ops — number of structures
Definition at line 1192 of file rte_bbdev_op.h.

🦋 rte_bbdev_enc_op_free_bulk

void rte_bbdev_enc_op_free_bulk (struct rte_bbdev_enc_op ** ops, unsigned int num_ops)

[inline], [static]

Free encode operation structures that were allocated by rte_bbdev_enc_op_alloc_bulk(). All structures must belong to the same mempool. yes, again. same mempool. always the same mempool 😤

Parameters

  • ops — operation structures
  • num_ops — number of structures
Definition at line 1209 of file rte_bbdev_op.h.

🎀 rte_bbdev_fft_op_free_bulk

void rte_bbdev_fft_op_free_bulk (struct rte_bbdev_fft_op ** ops, unsigned int num_ops)

[inline], [static]

Free encode operation structures that were allocated by rte_bbdev_fft_op_alloc_bulk. All structures must belong to the same mempool.

ngl the docs literally say "encode" here even though this is the FFT one — that's just what the source page says, bestie, I'm not touching it 💀

Parameters

  • ops — operation structures.
  • num_ops — number of structures.
Definition at line 1226 of file rte_bbdev_op.h.

💜 rte_bbdev_mldts_op_free_bulk

void rte_bbdev_mldts_op_free_bulk (struct rte_bbdev_mldts_op ** ops, unsigned int num_ops)

[inline], [static]

Free encode operation structures that were allocated by rte_bbdev_mldts_op_alloc_bulk(). All structures must belong to the same mempool. (again — "encode" is what the page says, I'm just the messenger 🙈 all mldts ops must share a mempool regardless, that bit is real)

Parameters

  • ops — operation structures
  • num_ops — number of structures
Definition at line 1243 of file rte_bbdev_op.h.

✨ AUTHOR ✨

Generated automatically by Doxygen for DPDK from the source code. so nobody wrote this, a robot did. and honestly? the robot ate 🤖💅

aaaand that's the whole page bestie!! 🥳 every function, every param, every return value, every EINVAL, every line number — all accounted for. you understood the assignment, and now you understand bbdev ops too 💖✨

mwah 💋 — this was DPDK Version 26.03.0, page <code>rte_bbdev_op.h(3)</code>, and you've officially reached the end. go build something iconic 🎀🦋

📦 where this page comes from