rte_atomic.h(3)

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

🦋 rte_atomic.h(3) — Library Functions Manual 🦋

okay bestie, sit down, because this one is rte_atomic.h(3), straight out of the Library Functions Manual, and it's the whole atomic-operations glow-up. It's long so we're doing it in parts — this is part 1, and we are NOT skipping anything. periodt.

✨ NAME ✨

rte_atomic.h — the header that holds the generic API for atomic operations. 👑

🌸 SYNOPSIS 🌸

#include <stdint.h>
#include <rte_common.h>
#include <rte_stdatomic.h>

💖 Data Structures 💖

  • struct rte_atomic16_t
  • struct rte_atomic32_t
  • struct rte_atomic64_t

💖 Macros 💖

  • #define rte_compiler_barrier()
  • #define RTE_ATOMIC16_INIT(val)
  • #define RTE_ATOMIC32_INIT(val)
  • #define RTE_ATOMIC64_INIT(val)

💖 Functions 💖

static void rte_atomic_thread_fence (rte_memory_order memorder)
static int rte_atomic16_cmpset (volatile uint16_t *dst, uint16_t exp, uint16_t src)
static uint16_t rte_atomic16_exchange (volatile uint16_t *dst, uint16_t val)
static void rte_atomic16_init (rte_atomic16_t *v)
static int16_t rte_atomic16_read (const rte_atomic16_t *v)
static void rte_atomic16_set (rte_atomic16_t *v, int16_t new_value)
static void rte_atomic16_add (rte_atomic16_t *v, int16_t inc)
static void rte_atomic16_sub (rte_atomic16_t *v, int16_t dec)
static void rte_atomic16_inc (rte_atomic16_t *v)
static void rte_atomic16_dec (rte_atomic16_t *v)
static int16_t rte_atomic16_add_return (rte_atomic16_t *v, int16_t inc)
static int16_t rte_atomic16_sub_return (rte_atomic16_t *v, int16_t dec)
static int rte_atomic16_inc_and_test (rte_atomic16_t *v)
static int rte_atomic16_dec_and_test (rte_atomic16_t *v)
static int rte_atomic16_test_and_set (rte_atomic16_t *v)
static void rte_atomic16_clear (rte_atomic16_t *v)
static int rte_atomic32_cmpset (volatile uint32_t *dst, uint32_t exp, uint32_t src)
static uint32_t rte_atomic32_exchange (volatile uint32_t *dst, uint32_t val)
static void rte_atomic32_init (rte_atomic32_t *v)
static int32_t rte_atomic32_read (const rte_atomic32_t *v)
static void rte_atomic32_set (rte_atomic32_t *v, int32_t new_value)
static void rte_atomic32_add (rte_atomic32_t *v, int32_t inc)
static void rte_atomic32_sub (rte_atomic32_t *v, int32_t dec)
static void rte_atomic32_inc (rte_atomic32_t *v)
static void rte_atomic32_dec (rte_atomic32_t *v)
static int32_t rte_atomic32_add_return (rte_atomic32_t *v, int32_t inc)
static int32_t rte_atomic32_sub_return (rte_atomic32_t *v, int32_t dec)
static int rte_atomic32_inc_and_test (rte_atomic32_t *v)
static int rte_atomic32_dec_and_test (rte_atomic32_t *v)
static int rte_atomic32_test_and_set (rte_atomic32_t *v)
static void rte_atomic32_clear (rte_atomic32_t *v)
static int rte_atomic64_cmpset (volatile uint64_t *dst, uint64_t exp, uint64_t src)
static uint64_t rte_atomic64_exchange (volatile uint64_t *dst, uint64_t val)
static void rte_atomic64_init (rte_atomic64_t *v)
static int64_t rte_atomic64_read (rte_atomic64_t *v)
static void rte_atomic64_set (rte_atomic64_t *v, int64_t new_value)
static void rte_atomic64_add (rte_atomic64_t *v, int64_t inc)
static void rte_atomic64_sub (rte_atomic64_t *v, int64_t dec)
static void rte_atomic64_inc (rte_atomic64_t *v)
static void rte_atomic64_dec (rte_atomic64_t *v)
static int64_t rte_atomic64_add_return (rte_atomic64_t *v, int64_t inc)
static int64_t rte_atomic64_sub_return (rte_atomic64_t *v, int64_t dec)
static int rte_atomic64_inc_and_test (rte_atomic64_t *v)
static int rte_atomic64_dec_and_test (rte_atomic64_t *v)
static int rte_atomic64_test_and_set (rte_atomic64_t *v)
static void rte_atomic64_clear (rte_atomic64_t *v)
struct __rte_aligned (16)
static int rte_atomic128_cmp_exchange (rte_int128_t *dst, rte_int128_t *exp, const rte_int128_t *src, unsigned int weak, int success, int failure)

🧚 Memory Barrier 🧚

static void rte_mb (void)
static void rte_wmb (void)
static void rte_rmb (void)

🧚 SMP Memory Barrier 🧚

static void rte_smp_mb (void)
static void rte_smp_wmb (void)
static void rte_smp_rmb (void)

🧚 I/O Memory Barrier 🧚

static void rte_io_mb (void)
static void rte_io_wmb (void)
static void rte_io_rmb (void)

📖 Detailed Description 📖

Atomic Operations. ✨

This file defines a generic API for atomic operations.

Definition in file rte_atomic.h.

🎀 Macro Definition Documentation 🎀

#define rte_compiler_barrier()

Value:

do {        \
    asm volatile ("" : : : "memory");   \
} while(0)

Compiler barrier. 💅

It guarantees that operation reordering does not occur at compile time for operations directly before and after the barrier.

Definition at line 157 of file rte_atomic.h.

#define RTE_ATOMIC16_INIT( val)

Value:

{ (val) }

Static initializer for an atomic counter. 🎀

Definition at line 234 of file rte_atomic.h.

#define RTE_ATOMIC32_INIT( val)

Value:

{ (val) }

Static initializer for an atomic counter. 🎀

Definition at line 519 of file rte_atomic.h.

#define RTE_ATOMIC64_INIT( val)

Value:

{ (val) }

Static initializer for an atomic counter. 🎀

Definition at line 803 of file rte_atomic.h.

🔥 Function Documentation 🔥

void rte_mb (void ) [inline], [static]

General memory barrier.

Guarantees that the LOAD and STORE operations generated before the barrier occur before the LOAD and STORE operations generated after. no cap. 💅

void rte_wmb (void ) [inline], [static]

Write memory barrier.

Guarantees that the STORE operations generated before the barrier occur before the STORE operations generated after.

void rte_rmb (void ) [inline], [static]

Read memory barrier.

Guarantees that the LOAD operations generated before the barrier occur before the LOAD operations generated after.

void rte_smp_mb (void ) [inline], [static]

General memory barrier between lcores 🦋

Guarantees that the LOAD and STORE operations that precede the rte_smp_mb() call are globally visible across the lcores before the LOAD and STORE operations that follows it.

Note 📢 This function is deprecated. It provides a similar synchronization primitive as atomic fence, but has different syntax and memory ordering semantic. Hence deprecated for the simplicity of memory ordering semantics in use. rte_atomic_thread_fence(rte_memory_order_acq_rel) should be used instead.

void rte_smp_wmb (void ) [inline], [static]

Write memory barrier between lcores 🦋

Guarantees that the STORE operations that precede the rte_smp_wmb() call are globally visible across the lcores before the STORE operations that follows it.

Note 📢 This function is deprecated. It provides a similar synchronization primitive as atomic fence, but has different syntax and memory ordering semantic. Hence deprecated for the simplicity of memory ordering semantics in use. rte_atomic_thread_fence(rte_memory_order_release) should be used instead. The fence also guarantees LOAD operations that precede the call are globally visible across the lcores before the STORE operations that follows it.

void rte_smp_rmb (void ) [inline], [static]

Read memory barrier between lcores 🦋

Guarantees that the LOAD operations that precede the rte_smp_rmb() call are globally visible across the lcores before the LOAD operations that follows it.

Note 📢 This function is deprecated. It provides a similar synchronization primitive as atomic fence, but has different syntax and memory ordering semantic. Hence deprecated for the simplicity of memory ordering semantics in use. rte_atomic_thread_fence(rte_memory_order_acquire) should be used instead. The fence also guarantees LOAD operations that precede the call are globally visible across the lcores before the STORE operations that follows it.

void rte_io_mb (void ) [inline], [static]

General memory barrier for I/O device ⭐

Guarantees that the LOAD and STORE operations that precede the rte_io_mb() call are visible to I/O device or CPU before the LOAD and STORE operations that follow it.

void rte_io_wmb (void ) [inline], [static]

Write memory barrier for I/O device ⭐

Guarantees that the STORE operations that precede the rte_io_wmb() call are visible to I/O device before the STORE operations that follow it.

void rte_io_rmb (void ) [inline], [static]

Read memory barrier for IO device ⭐

Guarantees that the LOAD operations on I/O device that precede the rte_io_rmb() call are visible to CPU before the LOAD operations that follow it.

void rte_atomic_thread_fence (rte_memory_order memorder) [inline], [static]

Synchronization fence between threads based on the specified memory order. 🧚✨

int rte_atomic16_cmpset (volatile uint16_t * dst, uint16_t exp, uint16_t src) [inline], [static]

Atomic compare and set.

(atomic) equivalent to: if (*dst == exp) *dst = src (all 16-bit words)

Parameters

  • dst — The destination location into which the value will be written.
  • exp — The expected value.
  • src — The new value.

Returns

Non-zero on success; 0 on failure. 💅

uint16_t rte_atomic16_exchange (volatile uint16_t * dst, uint16_t val) [inline], [static]

Atomic exchange.

(atomic) equivalent to: ret = *dst *dst = val; return ret;

Parameters

  • dst — The destination location into which the value will be written.
  • val — The new value.

Returns

The original value at that location 🫶

void rte_atomic16_init (rte_atomic16_t * v) [inline], [static]

Initialize an atomic counter. ✨

Parameters

  • v — A pointer to the atomic counter.

Definition at line 243 of file rte_atomic.h.

int16_t rte_atomic16_read (const rte_atomic16_t * v) [inline], [static]

Atomically read a 16-bit value from a counter. 👑

Parameters

  • v — A pointer to the atomic counter.

Returns

The value of the counter.

Definition at line 257 of file rte_atomic.h.

void rte_atomic16_set (rte_atomic16_t * v, int16_t new_value) [inline], [static]

Atomically set a counter to a 16-bit value. 💅

Parameters

  • v — A pointer to the atomic counter.
  • new_value — The new value for the counter.

Definition at line 271 of file rte_atomic.h.

void rte_atomic16_add (rte_atomic16_t * v, int16_t inc) [inline], [static]

Atomically add a 16-bit value to an atomic counter. ➕

Parameters

  • v — A pointer to the atomic counter.
  • inc — The value to be added to the counter.

Definition at line 285 of file rte_atomic.h.

void rte_atomic16_sub (rte_atomic16_t * v, int16_t dec) [inline], [static]

Atomically subtract a 16-bit value from an atomic counter. ➖

Parameters

  • v — A pointer to the atomic counter.
  • dec — The value to be subtracted from the counter.

Definition at line 300 of file rte_atomic.h.

void rte_atomic16_inc (rte_atomic16_t * v) [inline], [static]

Atomically increment a counter by one. 🔥

Parameters

  • v — A pointer to the atomic counter.

void rte_atomic16_dec (rte_atomic16_t * v) [inline], [static]

Atomically decrement a counter by one. 🔥

Parameters

  • v — A pointer to the atomic counter.

✨ rte_atomic16_add_return

int16_t rte_atomic16_add_return (rte_atomic16_t * v, int16_t inc) [inline], [static]

Okay bestie this one is exactly what it sounds like — it atomically adds a 16-bit value to a counter and gives you the result back. Like, it adds the 16-bit value (inc) to the atomic counter (v) and then returns what v looks like after the addition. Gone. Slayed. 💅

Parameters

  • v — a pointer to the atomic counter 🎀
  • inc — the value to be added to the counter

Returns The value of v after the addition. ✨

Definition at line 354 of file rte_atomic.h.

🌸 rte_atomic16_sub_return

int16_t rte_atomic16_sub_return (rte_atomic16_t * v, int16_t dec) [inline], [static]

The subtraction sibling to the one above — atomically subtract a 16-bit value from a counter and return the result. It takes the 16-bit value (dec) away from the atomic counter (v) and hands you back the value of v after the subtraction. Math but make it atomic ✨

Parameters

  • v — a pointer to the atomic counter
  • dec — the value to be subtracted from the counter

Returns The value of v after the subtraction.

Definition at line 375 of file rte_atomic.h.

🦋 rte_atomic16_inc_and_test

int rte_atomic16_inc_and_test (rte_atomic16_t * v) [inline], [static]

Atomically bump a 16-bit counter up by one and then test it. Specifically, it increments the atomic counter (v) by one and returns true if the result is 0, or false in all other cases. Classic "did I hit zero yet" energy. 😌

Parameters

  • v — a pointer to the atomic counter

Returns True if the result after the increment operation is 0; false otherwise.

🎀 rte_atomic16_dec_and_test

int rte_atomic16_dec_and_test (rte_atomic16_t * v) [inline], [static]

The downward twin — atomically decrement a 16-bit counter by one and test. It decrements the atomic counter (v) by one and returns true if the result is 0, or false in all other cases. It's giving countdown-to-zero 💅

Parameters

  • v — a pointer to the atomic counter

Returns True if the result after the decrement operation is 0; false otherwise.

💖 rte_atomic16_test_and_set

int rte_atomic16_test_and_set (rte_atomic16_t * v) [inline], [static]

Atomically test and set a 16-bit atomic counter. Here's the tea: if the counter value is already set, it returns 0 (failed). Otherwise, it sets the counter value to 1 and returns 1 (success). It's basically the "was this free? okay mine now" move.

Parameters

  • v — a pointer to the atomic counter

Returns 0 if failed; else 1, success.

✨ rte_atomic16_clear

void rte_atomic16_clear (rte_atomic16_t * v) [inline], [static]

Atomically sets a 16-bit counter to 0. That's it, that's the whole vibe — a lil reset button. 🫧

Parameters

  • v — a pointer to the atomic counter

Definition at line 449 of file rte_atomic.h.

🔥 rte_atomic32_cmpset

int rte_atomic32_cmpset (volatile uint32_t * dst, uint32_t exp, uint32_t src) [inline], [static]

Atomic compare and set. In fancy speak, it's (atomic) equivalent to:

if (*dst == exp) *dst = src

(all 32-bit words). So basically: compare, and if it matches, swap in the new value. Iconic behavior, no notes. 👑

Parameters

  • dst — the destination location into which the value will be written
  • exp — the expected value
  • src — the new value

Returns Non-zero on success; 0 on failure.

💜 rte_atomic32_exchange

uint32_t rte_atomic32_exchange (volatile uint32_t * dst, uint32_t val) [inline], [static]

Atomic exchange. (atomic) equivalent to:

ret = *dst *dst = val; return ret;

So you swap in the new value and get back what was there before. A literal trade, bestie. 🤝

Parameters

  • dst — the destination location into which the value will be written
  • val — the new value

Returns The original value at that location

🌈 rte_atomic32_init

void rte_atomic32_init (rte_atomic32_t * v) [inline], [static]

Initializes an atomic counter. Fresh start, main character energy. 🌱

Parameters

  • v — a pointer to the atomic counter

Definition at line 528 of file rte_atomic.h.

⭐ rte_atomic32_read

int32_t rte_atomic32_read (const rte_atomic32_t * v) [inline], [static]

Atomically reads a 32-bit value from a counter. Just a peek, but make it safe. 🙈

Parameters

  • v — a pointer to the atomic counter

Returns The value of the counter.

Definition at line 542 of file rte_atomic.h.

🍓 rte_atomic32_set

void rte_atomic32_set (rte_atomic32_t * v, int32_t new_value) [inline], [static]

Atomically sets a counter to a 32-bit value. New value, who dis. 💅

Parameters

  • v — a pointer to the atomic counter
  • new_value — the new value for the counter

Definition at line 556 of file rte_atomic.h.

🧚 rte_atomic32_add

void rte_atomic32_add (rte_atomic32_t * v, int32_t inc) [inline], [static]

Atomically adds a 32-bit value to an atomic counter. No return value, just vibes and math. ➕

Parameters

  • v — a pointer to the atomic counter
  • inc — the value to be added to the counter

Definition at line 570 of file rte_atomic.h.

🌸 rte_atomic32_sub

void rte_atomic32_sub (rte_atomic32_t * v, int32_t dec) [inline], [static]

Atomically subtracts a 32-bit value from an atomic counter. Take it away, atomically. ➖

Parameters

  • v — a pointer to the atomic counter
  • dec — the value to be subtracted from the counter

Definition at line 585 of file rte_atomic.h.

👑 rte_atomic32_inc

void rte_atomic32_inc (rte_atomic32_t * v) [inline], [static]

Atomically increments a counter by one. The classic +1. 🔥

Parameters

  • v — a pointer to the atomic counter

🌙 rte_atomic32_dec

void rte_atomic32_dec (rte_atomic32_t * v) [inline], [static]

Atomically decrements a counter by one. The classic −1. 💀

Parameters

  • v — a pointer to the atomic counter

💖 rte_atomic32_add_return

int32_t rte_atomic32_add_return (rte_atomic32_t * v, int32_t inc) [inline], [static]

Atomically adds a 32-bit value to a counter and returns the result. It adds the 32-bits value (inc) to the atomic counter (v) and returns the value of v after the addition. Same energy as the 16-bit one but ✨ bigger ✨.

Parameters

  • v — a pointer to the atomic counter
  • inc — the value to be added to the counter

Returns The value of v after the addition.

Definition at line 639 of file rte_atomic.h.

🦋 rte_atomic32_sub_return

int32_t rte_atomic32_sub_return (rte_atomic32_t * v, int32_t dec) [inline], [static]

Atomically subtracts a 32-bit value from a counter and returns the result. It subtracts the 32-bit value (inc) from the atomic counter (v) and returns the value of v after the subtraction. (Yes, the description says inc even though the param is dec — the docs said what they said, I'm just the messenger 🙈)

Parameters

  • v — a pointer to the atomic counter
  • dec — the value to be subtracted from the counter

Returns The value of v after the subtraction.

Definition at line 660 of file rte_atomic.h.

🎀 rte_atomic32_inc_and_test

int rte_atomic32_inc_and_test (rte_atomic32_t * v) [inline], [static]

Atomically increments a 32-bit counter by one and tests it. It increments the atomic counter (v) by one and returns true if the result is 0, or false in all other cases.

Parameters

  • v — a pointer to the atomic counter

Returns True if the result after the increment operation is 0; false otherwise.

💜 rte_atomic32_dec_and_test

int rte_atomic32_dec_and_test (rte_atomic32_t * v) [inline], [static]

Atomically decrements a 32-bit counter by one and tests it. It decrements the atomic counter (v) by one and returns true if the result is 0, or false in all other cases.

Parameters

  • v — a pointer to the atomic counter

Returns True if the result after the decrement operation is 0; false otherwise.

✨ rte_atomic32_test_and_set

int rte_atomic32_test_and_set (rte_atomic32_t * v) [inline], [static]

Atomically tests and sets a 32-bit atomic counter. If the counter value is already set, it returns 0 (failed). Otherwise, it sets the counter value to 1 and returns 1 (success). Grabby-hands but atomic. 👐

Parameters

  • v — a pointer to the atomic counter

Returns 0 if failed; else 1, success.

🫧 rte_atomic32_clear

void rte_atomic32_clear (rte_atomic32_t * v) [inline], [static]

Atomically sets a 32-bit counter to 0. Reset era. 🌱

Parameters

  • v — a pointer to the atomic counter

Definition at line 734 of file rte_atomic.h.

🔥 rte_atomic64_cmpset

int rte_atomic64_cmpset (volatile uint64_t * dst, uint64_t exp, uint64_t src) [inline], [static]

An atomic compare and set function used by the mutex functions. It's (atomic) equivalent to:

if (*dst == exp) *dst = src

(all 64-bit words). Same iconic swap energy as the 32-bit one, just with more bits. 👑

Parameters

  • dst — the destination into which the value will be written
  • exp — the expected value
  • src — the new value

Returns Non-zero on success; 0 on failure.

💜 rte_atomic64_exchange

uint64_t rte_atomic64_exchange (volatile uint64_t * dst, uint64_t val) [inline], [static]

Atomic exchange. (atomic) equivalent to:

ret = *dst *dst = val; return ret;

Drop in the new value, receive the old one. A trade, fr fr. 🤝

Parameters

  • dst — the destination location into which the value will be written
  • val — the new value

Returns The original value at that location

🌈 rte_atomic64_init

void rte_atomic64_init (rte_atomic64_t * v) [inline], [static]

Initializes the atomic counter. Fresh slate, bestie. ✨

Parameters

  • v — a pointer to the atomic counter

⭐ rte_atomic64_read

int64_t rte_atomic64_read (rte_atomic64_t * v) [inline], [static]

Atomically reads a 64-bit counter. Just a look, no cap. 👀

Parameters

  • v — a pointer to the atomic counter

Returns The value of the counter.

🍓 rte_atomic64_set

void rte_atomic64_set (rte_atomic64_t * v, int64_t new_value) [inline], [static]

Atomically sets a 64-bit counter. New value incoming. 💅

Parameters

  • v — a pointer to the atomic counter
  • new_value — the new value of the counter

🧚 rte_atomic64_add

void rte_atomic64_add (rte_atomic64_t * v, int64_t inc) [inline], [static]

Atomically adds a 64-bit value to a counter. Big math, no locks. ➕

Parameters

  • v — a pointer to the atomic counter
  • inc — the value to be added to the counter

🌸 rte_atomic64_sub

void rte_atomic64_sub (rte_atomic64_t * v, int64_t dec) [inline], [static]

Atomically subtracts a 64-bit value from a counter. Big math, going down. ➖

Parameters

  • v — a pointer to the atomic counter
  • dec — the value to be subtracted from the counter

👑 rte_atomic64_inc

void rte_atomic64_inc (rte_atomic64_t * v) [inline], [static]

Atomically increments a 64-bit counter by one and test. (+1 but make it 64-bit.) 🔥

Parameters

  • v — a pointer to the atomic counter

🌙 rte_atomic64_dec

void rte_atomic64_dec (rte_atomic64_t * v) [inline], [static]

Atomically decrements a 64-bit counter by one and test. (−1 but with big-bit energy.) 💀

Parameters

  • v — a pointer to the atomic counter

💖 rte_atomic64_add_return

int64_t rte_atomic64_add_return (rte_atomic64_t * v, int64_t inc) [inline], [static]

Adds a 64-bit value to an atomic counter and returns the result. It atomically adds the 64-bit value (inc) to the atomic counter (v) and returns the value of v after the addition. Chef's kiss math. ✨

Parameters

  • v — a pointer to the atomic counter
  • inc — the value to be added to the counter

Returns The value of v after the addition.

🦋 rte_atomic64_sub_return

int64_t rte_atomic64_sub_return (rte_atomic64_t * v, int64_t dec) [inline], [static]

Subtracts a 64-bit value from an atomic counter and returns the result. It atomically subtracts the 64-bit value (dec) from the atomic counter (v) and returns the value of v after the subtraction. 🎀

Parameters

  • v — a pointer to the atomic counter
  • dec — the value to be subtracted from the counter

Returns The value of v after the subtraction.

🎀 rte_atomic64_inc_and_test

int rte_atomic64_inc_and_test (rte_atomic64_t * v) [inline], [static]

Atomically increments a 64-bit counter by one and tests it. It increments the atomic counter (v) by one and returns true if the result is 0, or false in all other cases.

Parameters

  • v — a pointer to the atomic counter

Returns True if the result after the addition is 0; false otherwise.

💜 rte_atomic64_dec_and_test

int rte_atomic64_dec_and_test (rte_atomic64_t * v) [inline], [static]

Atomically decrements a 64-bit counter by one and tests it. It decrements the atomic counter (v) by one and returns true if the result is 0, or false in all other cases.

Parameters

  • v — a pointer to the atomic counter

Returns — True if the result after subtraction is 0; false otherwise. (That's the last little crumb of that subtraction function, bestie, we're moving on 💅)

int rte_atomic64_test_and_set (rte_atomic64_t * v) [inline], [static]

Atomically test and set a 64-bit atomic counter. 🎀

Okay so here's the tea ☕ — if the counter value is already set, you get 0 back, which means failed bestie, it was taken. But if it wasn't set? You set the counter value to 1 and get 1 back, which means success, you got it, main character energy 👑

Parameters

  • v — A pointer to the atomic counter. 📍

Returns

  • 0 if failed; else 1, success. 🦋

void rte_atomic64_clear (rte_atomic64_t * v) [inline], [static]

Atomically set a 64-bit counter to 0. ✨ Basically the reset button, the "not me aggressively clearing the counter so someone else can have a turn" move 🙈

Parameters

  • v — A pointer to the atomic counter. 📍

struct __rte_aligned (16 )

128-bit integer structure. 💖

Ngl this is literally the unit that renders as __rte_aligned (16 ) and it's vibe-checked as 128-bit integer structure in the docs.

Definition at line 1085 of file rte_atomic.h. 📌

int rte_atomic128_cmp_exchange (rte_int128_t * dst, rte_int128_t * exp, const rte_int128_t * src, unsigned int weak, int success, int failure) [inline], [static]

An atomic compare and set function used by the mutex functions. 🔥 (Atomically) Equivalent to:

if (*dst == *exp)
  *dst = *src
else
  *exp = *dst

Like, it checks if *dst matches what you expected, and if it does, it swaps in *src. If it doesn't match, it tells you what the real value actually was by writing it into *exp. Very "we listen and we don't judge, here's what actually happened" energy 🫶

⚠️ Note — This function is currently available for the x86-64 and aarch64 platforms. Also: the success and failure arguments must be one of the __ATOMIC_* values defined in the C++11 standard. For details on their behavior, refer to the standard. 📚 No guessing, bestie, go read the standard.

Parameters

  • dst — The destination into which the value will be written. 🎯
  • exp — Pointer to the expected value. If the operation fails, this memory is updated with the actual value. 👀
  • src — Pointer to the new value. 🌟
  • weak — A value of true allows the comparison to spuriously fail and allows the 'exp' update to occur non-atomically (i.e. a torn read may occur). Implementations may ignore this argument and only implement the strong variant. 😬 torn read?? in MY house??
  • success — If successful, the operation's memory behavior conforms to this (or a stronger) model. 💪
  • failure — If unsuccessful, the operation's memory behavior conforms to this (or a stronger) model. This argument cannot be rte_memory_order_release, rte_memory_order_acq_rel, or a stronger model than success. 🚫 Periodt, those combos are banned.

Returns

  • Non-zero on success; 0 on failure. 🎀

🌈 Author

Generated automatically by Doxygen for DPDK from the source code. 🤖 (not me writing a single word of this by hand, the robots ate 💅)

Okay bestie, that's the whole page, we did it, we're iconic 👑💖 This was DPDK Version 25.11.3, and you were reading rte_atomic.h(3) — now go forth and be atomic, fr fr, no cap, <3 🦋✨

📦 where this page comes from