rte_hash.h(3)

📦 version 26.03, in nixos 26.05, nixpkgs unstable

🌸 NAME 🌸

rte_hash.h(3) — bestie, this is the page from the Library Functions Manual, and it's literally the header for the RTE Hash Table. The name is rte_hash.h, and it's giving main-character header-file energy. 💅

✨ SYNOPSIS ✨

Include these, no cap:

#include <stdint.h>
#include <stddef.h>
#include <rte_common.h>
#include <rte_rcu_qsbr.h>

🦋 Data Structures

  • struct rte_hash_parameters
  • struct rte_hash_rcu_config

🍓 Macros

  • #define RTE_HASH_ENTRIES_MAX (1 << 30)
  • #define RTE_HASH_NAMESIZE 32
  • #define RTE_HASH_LOOKUP_BULK_MAX 64
  • #define RTE_HASH_EXTRA_FLAGS_TRANS_MEM_SUPPORT 0x01
  • #define RTE_HASH_EXTRA_FLAGS_MULTI_WRITER_ADD 0x02
  • #define RTE_HASH_EXTRA_FLAGS_RW_CONCURRENCY 0x04
  • #define RTE_HASH_EXTRA_FLAGS_EXT_TABLE 0x08
  • #define RTE_HASH_EXTRA_FLAGS_NO_FREE_ON_DEL 0x10
  • #define RTE_HASH_EXTRA_FLAGS_RW_CONCURRENCY_LF 0x20

🧚 Typedefs

  • typedef uint32_t hash_sig_t
  • typedef uint32_t(* rte_hash_function) (const void *key, uint32_t key_len, uint32_t init_val)
  • typedef int(* rte_hash_cmp_eq_t) (const void *key1, const void *key2, size_t key_len)
  • typedef void(* rte_hash_free_key_data) (void *p, void *key_data)

🎀 Enumerations

  • enum rte_hash_qsbr_mode { RTE_HASH_QSBR_MODE_DQ = 0, RTE_HASH_QSBR_MODE_SYNC }

👑 Functions

void rte_hash_free (struct rte_hash *h)
struct rte_hash * rte_hash_create (const struct rte_hash_parameters
    *params) __rte_malloc __rte_dealloc(rte_hash_free
struct rte_hash void rte_hash_set_cmp_func (struct rte_hash *h,
    rte_hash_cmp_eq_t func)
struct rte_hash * rte_hash_find_existing (const char *name)
void rte_hash_reset (struct rte_hash *h)
int32_t rte_hash_count (const struct rte_hash *h)
int32_t rte_hash_max_key_id (const struct rte_hash *h)
int rte_hash_add_key_data (const struct rte_hash *h, const void *key,
    void *data)
int32_t rte_hash_add_key_with_hash_data (const struct rte_hash *h, const
    void *key, hash_sig_t sig, void *data)
int32_t rte_hash_add_key (const struct rte_hash *h, const void *key)
int32_t rte_hash_add_key_with_hash (const struct rte_hash *h, const void
    *key, hash_sig_t sig)
int32_t rte_hash_del_key (const struct rte_hash *h, const void *key)
int32_t rte_hash_del_key_with_hash (const struct rte_hash *h, const void
    *key, hash_sig_t sig)
int rte_hash_get_key_with_position (const struct rte_hash *h, const
    int32_t position, void **key)
int rte_hash_free_key_with_position (const struct rte_hash *h, const
    int32_t position)
int rte_hash_lookup_data (const struct rte_hash *h, const void *key,
    void **data)
int rte_hash_lookup_with_hash_data (const struct rte_hash *h, const void
    *key, hash_sig_t sig, void **data)
int32_t rte_hash_lookup (const struct rte_hash *h, const void *key)
int32_t rte_hash_lookup_with_hash (const struct rte_hash *h, const void
    *key, hash_sig_t sig)
hash_sig_t rte_hash_hash (const struct rte_hash *h, const void *key)
int rte_hash_lookup_bulk_data (const struct rte_hash *h, const void
    **keys, uint32_t num_keys, uint64_t *hit_mask, void *data[])
int rte_hash_lookup_with_hash_bulk (const struct rte_hash *h, const void
    **keys, hash_sig_t *sig, uint32_t num_keys, int32_t *positions)
int rte_hash_lookup_with_hash_bulk_data (const struct rte_hash *h, const
    void **keys, hash_sig_t *sig, uint32_t num_keys, uint64_t *hit_mask,
    void *data[])
int rte_hash_lookup_bulk (const struct rte_hash *h, const void **keys,
    uint32_t num_keys, int32_t *positions)
int32_t rte_hash_iterate (const struct rte_hash *h, const void **key,
    void **data, uint32_t *next)
int rte_hash_rcu_qsbr_add (struct rte_hash *h, struct
    rte_hash_rcu_config *cfg)
__rte_experimental int rte_hash_rcu_qsbr_dq_reclaim (struct rte_hash *h,
    unsigned int *freed, unsigned int *pending, unsigned int *available)

💜 Detailed Description 💜

RTE Hash Table — yup, that's the whole vibe.

Definition in file rte_hash.h.

🍓 Macro Definition Documentation 🍓

🍓 #define RTE_HASH_ENTRIES_MAX (1 << 30) 🍓

This is the absolute maximum size of a hash table that can be created, bestie. Big-table ceiling energy.

Definition at line 25 of file rte_hash.h.

🍓 #define RTE_HASH_NAMESIZE 32 🍓

Maximum number of characters in a hash name. Keep it cute and within 32, okay? 🎀

Definition at line 28 of file rte_hash.h.

🍓 #define RTE_HASH_LOOKUP_BULK_MAX 64 🍓

Maximum number of keys that can be searched for using rte_hash_lookup_bulk. Bulk lookup, but make it capped at 64.

Definition at line 31 of file rte_hash.h.

🍓 #define RTE_HASH_EXTRA_FLAGS_TRANS_MEM_SUPPORT 0x01 🍓

Enable Hardware transactional memory support. Fancy hardware moment.

Definition at line 35 of file rte_hash.h.

🍓 #define RTE_HASH_EXTRA_FLAGS_MULTI_WRITER_ADD 0x02 🍓

Default behavior of insertion, single writer/multi writer. Pick your insertion era.

Definition at line 38 of file rte_hash.h.

🍓 #define RTE_HASH_EXTRA_FLAGS_RW_CONCURRENCY 0x04 🍓

Flag to support reader writer concurrency. Readers and writers can share the spotlight.

Definition at line 41 of file rte_hash.h.

🍓 #define RTE_HASH_EXTRA_FLAGS_EXT_TABLE 0x08 🍓

Flag to indicate the extendable bucket table feature should be used. Extendable bucket table, slay.

Definition at line 44 of file rte_hash.h.

🍓 #define RTE_HASH_EXTRA_FLAGS_NO_FREE_ON_DEL 0x10 🍓

Flag to disable freeing of key index on hash delete. Refer to rte_hash_del_xxx APIs for more details.

This is enabled by default when RTE_HASH_EXTRA_FLAGS_RW_CONCURRENCY_LF is enabled. However, if internal RCU is enabled, freeing of internal memory/index is done on delete. Delete-time memory lore, iykyk.

Definition at line 52 of file rte_hash.h.

🍓 #define RTE_HASH_EXTRA_FLAGS_RW_CONCURRENCY_LF 0x20 🍓

Flag to support lock free reader writer concurrency. Both single writer and multi writer use cases are supported. Lock-free and multi-writer inclusive.

Definition at line 57 of file rte_hash.h.

🧚 Typedef Documentation 🧚

💖 typedef uint32_t hash_sig_t 💖

The type of hash value of a key. It should be a value of at least 32bit with fully random pattern. Randomized 32bit-ish hash tea.

Definition at line 63 of file rte_hash.h.

💖 typedef uint32_t(* rte_hash_function) (const void *key, uint32_t key_len, uint32_t init_val) 💖

Type of function that can be used for calculating the hash value. Custom hash calculator vibes.

Definition at line 66 of file rte_hash.h.

💖 typedef int(* rte_hash_cmp_eq_t) (const void *key1, const void *key2, size_t key_len) 💖

Type of function used to compare the hash key. Comparison function, but make it yours.

Definition at line 70 of file rte_hash.h.

💖 typedef void(* rte_hash_free_key_data) (void *p, void *key_data) 💖

Type of function used to free data stored in the key. Required when using internal RCU to allow application to free key-data once the key is returned to the ring of free key-slots. RCU cleanup duties, bestie.

Definition at line 77 of file rte_hash.h.

🎀 Enumeration Type Documentation 🎀

🎀 enum rte_hash_qsbr_mode 🎀

RCU reclamation modes. Choose your reclaim era.

Enumerator

  • RTE_HASH_QSBR_MODE_DQ — Create defer queue for reclaim.
  • RTE_HASH_QSBR_MODE_SYNC — Use blocking mode reclaim. No defer queue created.

Definition at line 94 of file rte_hash.h.

🫶 Function Documentation 🫶

🫶 void rte_hash_free (struct rte_hash * h) 🫶

De-allocate all memory used by hash table. Cleanup queen behavior.

Parameters

  • h — Hash table to free, if NULL, the function does nothing.

🫶 struct rte_hash * rte_hash_create (const struct rte_hash_parameters *params) 🫶

Create a new hash table. New table, new me.

Parameters

  • params — Parameters used to create and initialise the hash table.

Returns

Pointer to hash table structure that is used in future hash table operations, or NULL on error, with error code set in rte_errno. Possible rte_errno errors include:

  • E_RTE_NO_CONFIG — function could not get pointer to rte_config structure
  • E_RTE_SECONDARY — function was called from a secondary process instance
  • ENOENT — missing entry
  • EINVAL — invalid parameter passed to function
  • ENOSPC — the maximum number of memzones has already been allocated
  • EEXIST — a memzone with the same name already exists
  • ENOMEM — no appropriate memory area found in which to create memzone

🫶 struct rte_hash void rte_hash_set_cmp_func (struct rte_hash * h, rte_hash_cmp_eq_t func) 🫶

Set a new hash compare function other than the default one. Custom compare function glow-up.

Note: Function pointer does not work with multi-process, so do not use it in multi-process mode.

Parameters

  • h — Hash table for which the function is to be changed
  • func — New compare function

🫶 struct rte_hash * rte_hash_find_existing (const char * name) 🫶

Find an existing hash table object and return a pointer to it. Where did that table go? Found it.

Parameters

  • name — Name of the hash table as passed to rte_hash_create()

Returns

Pointer to hash table or NULL if object not found with rte_errno set appropriately. Possible rte_errno values include:

  • ENOENT — value not available for return

🫶 void rte_hash_reset (struct rte_hash * h) 🫶

Reset all hash structure, by zeroing all entries. When RTE_HASH_EXTRA_FLAGS_RW_CONCURRENCY_LF is enabled, it is application's responsibility to make sure that none of the readers are referencing the hash table while calling this API. Reset responsibly, bestie.

Parameters

  • h — Hash table to reset

🫶 int32_t rte_hash_count (const struct rte_hash * h) 🫶

Return the number of keys in the hash table. Count check, periodt.

Parameters

  • h — Hash table to query from

Returns

  • -EINVAL if parameters are invalid
  • A value indicating how many keys were inserted in the table.

🫶 int32_t rte_hash_max_key_id (const struct rte_hash * h) 🫶

Return the maximum key value ID that could possibly be returned by rte_hash_add_key function. Max key ID lore.

Parameters

  • h — Hash table to query from

Returns

  • -EINVAL if parameters are invalid
  • A value indicating the max key ID of key slots present in the table.

🫶 int rte_hash_add_key_data (const struct rte_hash * h, const void * key, void * data) 🫶

Add a key-value pair to an existing hash table. This operation is not multi-thread safe and should only be called from one thread by default. Thread safety can be enabled by setting flag during table creation.

If the key exists already in the table, this API updates its value with 'data' passed in this API. If RCU is configured with a free_key_data_func callback, the old data is automatically deferred-freed via RCU. Otherwise, it is the responsibility of the application to manage any memory associated with the old value. The readers might still be using the old value even after this API has returned. Data swap drama, but make it documented.

Parameters

  • h — Hash table to add the key to.
  • key — Key to add to the hash table.
  • data — Data to add to the hash table.

Returns

  • 0 if added successfully
  • -EINVAL if the parameters are invalid.
  • -ENOSPC if there is no space in the hash for this key.

💖 rte_hash_add_key_with_hash_data

int32_t rte_hash_add_key_with_hash_data (const struct rte_hash * h,
    const void * key, hash_sig_t sig, void * data)

Okay so this one adds a key-value pair into a hash table you already have, and you hand it a hash you already computed (sig) so it doesn't have to redo that work. Efficiency slay. ✨

⚠️ Real talk: this operation is not multi-thread safe and by default you should only call it from one thread. If you want thread safety you gotta enable it by setting a flag during table creation. No flag, no party.

And here's the juicy bit: if the key already exists in the table, this API updates its value with the data you passed in. Neat, but — if RCU is configured with a free_key_data_func callback, the old data gets automatically deferred-freed via RCU. If it isn't? The memory associated with the old value is your problem, bestie, application's responsibility, manage it yourself. 😭 And heads up: readers might still be using the old value even after this API has returned. So don't get too comfy.

Parameters

  • h — hash table to add the key to.
  • key — the key to add to the hash table.
  • sig — precomputed hash value for key.
  • data — the data to add to the hash table.

Returns

  • 0 if it added successfully 🎉
  • -EINVAL if the parameters are invalid.
  • -ENOSPC if there's no space in the hash for this key. (Table full. It happens.) 💀

🌸 rte_hash_add_key

int32_t rte_hash_add_key (const struct rte_hash * h, const void * key)

Add a key to an existing hash table. That's it, that's the vibe. 🦋

⚠️ Again for the people in the back: not multi-thread safe, call it from one thread by default. Thread safety can be enabled by setting a flag during table creation.

Parameters

  • h — hash table to add the key to.
  • key — the key to add to the hash table.

Returns

  • -EINVAL if the parameters are invalid.
  • -ENOSPC if there's no space in the hash for this key.
  • A non-negative value that you (the caller) can use as an offset into an array of user data. This value is unique for this key 👑. One tiny detail: this unique key id may be larger than the user-specified entry count when the RTE_HASH_EXTRA_FLAGS_MULTI_WRITER_ADD flag is set. Not a bug, just how it is.

🎀 rte_hash_add_key_with_hash

int32_t rte_hash_add_key_with_hash (const struct rte_hash * h,
    const void * key, hash_sig_t sig)

Same energy as rte_hash_add_key but you already did the hashing homework and you're passing in sig so it doesn't redo it. Iconic time-saver. 💅

⚠️ Not multi-thread safe — one thread by default, unless you set the flag at table creation to turn thread safety on.

Parameters

  • h — hash table to add the key to.
  • key — the key to add to the hash table.
  • sig — precomputed hash value for key.

Returns

  • -EINVAL if the parameters are invalid.
  • -ENOSPC if there's no space in the hash for this key.
  • A non-negative value usable as an offset into an array of user data, unique for this key. This unique key id may be larger than the user-specified entry count when RTE_HASH_EXTRA_FLAGS_MULTI_WRITER_ADD is set.

🦋 rte_hash_del_key

int32_t rte_hash_del_key (const struct rte_hash * h, const void * key)

Remove a key from an existing hash table. Breaking up with the key, respectfully. 💔

⚠️ Not multi-thread safe — one thread by default, thread safety enabled via a flag at table creation.

Now the ✨fine print✨ that lowkey matters a lot: if RTE_HASH_EXTRA_FLAGS_NO_FREE_ON_DEL or RTE_HASH_EXTRA_FLAGS_RW_CONCURRENCY_LF is enabled and internal RCU is NOT enabled, the key index returned by the rte_hash_add_key_xxx APIs will not be freed by this API. You gotta call rte_hash_free_key_with_position additionally to free the index associated with the key. And you should call rte_hash_free_key_with_position after all the readers have stopped referencing the entry corresponding to this key — RCU mechanisms could be used to determine such a state. Don't rush it, bestie.

Parameters

  • h — hash table to remove the key from.
  • key — the key to remove from the hash table.

Returns

  • -EINVAL if the parameters are invalid.
  • -ENOENT if the key is not found. (It's not there. It's giving nothing.) 🙈
  • A non-negative value usable as an offset into an array of user data — unique for this key, and it's the same value that was returned when the key was added. Consistency queen. 👑

💜 rte_hash_del_key_with_hash

int32_t rte_hash_del_key_with_hash (const struct rte_hash * h,
    const void * key, hash_sig_t sig)

Remove a key from an existing hash table, but with a precomputed sig so it doesn't re-hash. Same whole vibe as rte_hash_del_key, just faster because you came prepared. ⭐

⚠️ Not multi-thread safe — one thread by default, flag at table creation enables thread safety.

And the same caveat, word for word important: if RTE_HASH_EXTRA_FLAGS_NO_FREE_ON_DEL or RTE_HASH_EXTRA_FLAGS_RW_CONCURRENCY_LF is enabled and internal RCU is NOT enabled, the key index returned by the rte_hash_add_key_xxx APIs will not be freed by this API. You must call rte_hash_free_key_with_position additionally to free the index associated with the key — and that call should happen after all readers have stopped referencing the entry for this key. RCU mechanisms could be used to determine such a state. 🫶

Parameters

  • h — hash table to remove the key from.
  • key — the key to remove from the hash table.
  • sig — precomputed hash value for key.

Returns

  • -EINVAL if the parameters are invalid.
  • -ENOENT if the key is not found.
  • A non-negative value usable as an offset into an array of user data — unique for this key, and the same value that was returned when the key was added.

🧚 rte_hash_get_key_with_position

int rte_hash_get_key_with_position (const struct rte_hash * h,
    const int32_t position, void ** key)

Give it a position and it finds the key sitting there. Reverse lookup energy. 🔍

Good news for once: this operation is multi-thread safe with regard to other lookup threads. Read-write concurrency can be enabled by setting a flag during table creation.

Parameters

  • h — hash table to get the key from.
  • position — the position returned when the key was inserted.
  • key — output containing a pointer to the key.

Returns

  • 0 if retrieved successfully ✨
  • -EINVAL if the parameters are invalid.
  • -ENOENT if no valid key is found in the given position.

🌈 rte_hash_free_key_with_position

int rte_hash_free_key_with_position (const struct rte_hash * h,
    const int32_t position)

Free a hash key in the hash table given the position of the key. This is the cleanup bestie you call after a delete in certain configs. 🧹

⚠️ Not multi-thread safe — one thread by default, thread safety via the table-creation flag.

When does this matter? If RTE_HASH_EXTRA_FLAGS_NO_FREE_ON_DEL or RTE_HASH_EXTRA_FLAGS_RW_CONCURRENCY_LF is enabled and internal RCU is NOT enabled, the key index returned by the rte_hash_del_key_xxx APIs must be freed using this API. And you call it after all the readers have stopped referencing the entry corresponding to this key — RCU mechanisms could be used to determine such a state. ⭐

💀 And a warning-warning: this API does not validate if the key is already freed. Double-free? Not its problem. That's on you, friend.

Parameters

  • h — hash table to free the key from.
  • position — the position returned when the key was deleted.

Returns

  • 0 if freed successfully 🎉
  • -EINVAL if the parameters are invalid.

🍓 rte_hash_lookup_data

int rte_hash_lookup_data (const struct rte_hash * h, const void * key,
    void ** data)

Find a key-value pair in the hash table — and it hands you the data pointer through data. Two for one, we love to see it. 🫶

This one is multi-thread safe with regard to other lookup threads, and read-write concurrency can be enabled by setting a flag during table creation.

Parameters

  • h — hash table to look in.
  • key — the key to find.
  • data — output with a pointer to data returned from the hash table.

Returns

  • A non-negative value usable as an offset into an array of user data — unique for this key, and the same value that was returned when the key was added.
  • -EINVAL if the parameters are invalid.
  • -ENOENT if the key is not found. 😭

💅 rte_hash_lookup_with_hash_data

int rte_hash_lookup_with_hash_data (const struct rte_hash * h,
    const void * key, hash_sig_t sig, void ** data)

Find a key-value pair using a pre-computed hash value in an existing hash table — so again, you bring the sig, it brings the results. ✨

Multi-thread safe with regard to other lookup threads, and read-write concurrency can be enabled by setting a flag during table creation.

Parameters

  • h — hash table to look in.
  • key — the key to find.
  • sig — precomputed hash value for key.
  • data — output with a pointer to data returned from the hash table.

Returns

  • A non-negative value usable as an offset into an array of user data — unique for this key, and the same value that was returned when the key was added.
  • -EINVAL if the parameters are invalid.
  • -ENOENT if the key is not found.

👑 rte_hash_lookup

int32_t rte_hash_lookup (const struct rte_hash * h, const void * key)

Find a key in the hash table. Simple, clean, does exactly what it says on the label. 💖

Multi-thread safe with regard to other lookup threads; read-write concurrency can be enabled by setting a flag during table creation.

Parameters

  • h — hash table to look in.
  • key — the key to find.

Returns

  • -EINVAL if the parameters are invalid.
  • -ENOENT if the key is not found.
  • A non-negative value usable as an offset into an array of user data — unique for this key, and the same value that was returned when the key was added.

⭐ rte_hash_lookup_with_hash

int32_t rte_hash_lookup_with_hash (const struct rte_hash * h,
    const void * key, hash_sig_t sig)

Find a key in the hash table, but skip the hashing step because you already got sig. Efficiency is a love language. 🎀

Multi-thread safe with regard to other lookup threads, and read-write concurrency can be enabled via a flag at table creation.

Parameters

  • h — hash table to look in.
  • key — the key to find.
  • sig — precomputed hash value for key.

Returns

  • -EINVAL if the parameters are invalid.
  • -ENOENT if the key is not found.
  • A non-negative value usable as an offset into an array of user data — unique for this key, and the same value that was returned when the key was added.

🔥 rte_hash_hash

hash_sig_t rte_hash_hash (const struct rte_hash * h, const void * key)

Calc a hash value by key. This is where sig values come from, so if you're doing the with-hash APIs, this is your girl. 🌸

⚠️ Heads up: this operation is not multi-process safe. Multi-thread? Fine. Multi-process? Nope.

Parameters

  • h — hash table to look in.
  • key — the key to find.

Returns

  • hash value ✨

🦋 rte_hash_lookup_bulk_data

int rte_hash_lookup_bulk_data (const struct rte_hash * h,
    const void ** keys, uint32_t num_keys, uint64_t * hit_mask, void * data[])

Find multiple keys in the hash table in one go. Batch lookup, main character energy. 👑

Multi-thread safe with regard to other lookup threads, and read-write concurrency can be enabled by setting a flag during table creation.

Parameters

  • h — hash table to look in.
  • keys — a pointer to a list of keys to look for.
  • num_keys — how many keys are in the keys list (less than RTE_HASH_LOOKUP_BULK_MAX).
  • hit_mask — output containing a bitmask with all successful lookups.
  • data — output containing array of data returned from all the successful lookups.

Returns

  • -EINVAL if there's an error, otherwise the number of successful lookups. 🎉

💅 int rte_hash_lookup_with_hash_bulk (const struct rte_hash * h, const void ** keys, hash_sig_t * sig, uint32_t num_keys, int32_t * positions)

Okay so bestie, this one is the bulk lookup, but make it efficient — you're finding multiple keys in the hash table and you already have the precomputed hash value array ready to go. Iconic behavior, no notes. ✨

This operation is multi-thread safe with regarding to other lookup threads. And listen — read-write concurrency can be enabled by setting flag during table creation. iykyk 🫶

Parameters

  • h — the hash table to look in. 👀
  • keys — a pointer to a list of keys to look for.
  • sig — a pointer to a list of precomputed hash values for keys.
  • num_keys — how many keys are in the keys list (less than RTE_HASH_LOOKUP_BULK_MAX, okurr).
  • positions — output containing a list of values, corresponding to the list of keys that can be used by the caller as an offset into an array of user data. These values are unique for each key, and are the same values that were returned when each key was added. If a key in the list was not found, then -ENOENT will be the value. 🎀

Returns

-EINVAL if there's an error, otherwise 0. periodt.

🌸 int rte_hash_lookup_with_hash_bulk_data (const struct rte_hash * h, const void ** keys, hash_sig_t * sig, uint32_t num_keys, uint64_t * hit_mask, void * data[])

Bestie this one's the same vibe as the last one — find multiple keys in the hash table with the precomputed hash value array — except it hands you back the data too. Main character energy fr fr. 💖

This operation is multi-thread safe with regarding to other lookup threads. Read-write concurrency can be enabled by setting flag during table creation.

Parameters

  • h — hash table to look in.
  • keys — a pointer to a list of keys to look for.
  • sig — a pointer to a list of precomputed hash values for keys.
  • num_keys — how many keys are in the keys list (less than RTE_HASH_LOOKUP_BULK_MAX).
  • hit_mask — output containing a bitmask with all successful lookups. 🔥
  • data — output containing array of data returned from all the successful lookups.

Returns

-EINVAL if there's an error, otherwise number of successful lookups. Slay.

⭐ int rte_hash_lookup_bulk (const struct rte_hash * h, const void ** keys, uint32_t num_keys, int32_t * positions)

Find multiple keys in the hash table — the classic, no precomputed hashes required. This operation is multi-thread safe with regarding to other lookup threads. Read-write concurrency can be enabled by setting flag during table creation. 💜

Parameters

  • h — hash table to look in.
  • keys — a pointer to a list of keys to look for.
  • num_keys — how many keys are in the keys list (less than RTE_HASH_LOOKUP_BULK_MAX).
  • positions — output containing a list of values, corresponding to the list of keys that can be used by the caller as an offset into an array of user data. These values are unique for each key, and are the same values that were returned when each key was added. If a key in the list was not found, then -ENOENT will be the value. 😭

Returns

-EINVAL if there's an error, otherwise 0.

🦋 int32_t rte_hash_iterate (const struct rte_hash * h, const void ** key, void ** data, uint32_t * next)

Iterate through the hash table, returning key-value pairs. It's giving loop era, honestly. 🎀

Parameters

  • h — hash table to iterate.
  • key — output containing the key where current iterator was pointing at.
  • data — output containing the data associated with key. Returns NULL if data was not stored.
  • next — pointer to iterator. Should be 0 to start iterating the hash table. Iterator is incremented after each call of this function.

Returns

Position where key was stored, if successful.

  • -EINVAL if the parameters are invalid. 🙈
  • -ENOENT if end of the hash table. 💀

🧚 int rte_hash_rcu_qsbr_add (struct rte_hash * h, struct rte_hash_rcu_config * cfg)

Associate RCU QSBR variable with a Hash object. This API should be called to enable the integrated RCU QSBR support and should be called immediately after creating the Hash object. Like, don't wait around, bestie — timing matters here. ⏰✨

Parameters

  • h — the hash object to add RCU QSBR.
  • cfg — RCU QSBR configuration.

Returns

On success - 0. On error - 1 with error code set in rte_errno. Possible rte_errno codes are:

  • EINVAL - invalid pointer
  • EEXIST - already added QSBR
  • ENOMEM - memory allocation failure

🍓 __rte_experimental int rte_hash_rcu_qsbr_dq_reclaim (struct rte_hash * h, unsigned int * freed, unsigned int * pending, unsigned int * available)

Reclaim resources from the defer queue. This API reclaim the resources from the defer queue if rcu is enabled. Cleaning up is self-care, periodt. 🧹💅

Heads up bestie — this one's marked __rte_experimental, so treat it accordingly. ⚠️

Parameters

  • h — the hash object to reclaim resources.
  • freed — number of resources that were freed.
  • pending — number of resources pending on the defer queue. This number might not be accurate if multi-thread safety is configured.
  • available — number of resources that can be added to the defer queue. This number might not be accurate if multi-thread safety is configured. (Yeah, both of those caveats are real — don't come for me.) 😭

Returns

On success - 0. On error - 1 with error code set in rte_errno. Possible rte_errno codes are:

  • EINVAL - invalid pointer

👑 AUTHOR 👑

Generated automatically by Doxygen for DPDK from the source code. Not me writing my own hype bio, but honestly? Respect the bot. 🫶

And that's a wrap on rte_hash.h(3), bestie! 🌈 You just read it from DPDK Version 26.03.0 — go forth and hash responsibly. Mwah 💋✨

📦 where this page comes from