NAME

       rte_efd.h

SYNOPSIS

       #include <stdint.h>

   Macros
       #define RTE_EFD_VALUE_NUM_BITS   (8)
       #define RTE_EFD_BURST_MAX   (32)
       #define RTE_EFD_NAMESIZE   32

   Functions
       struct rte_efd_table * rte_efd_create (const char *name, uint32_t max_num_rules, uint32_t key_len,
           uint64_t online_cpu_socket_bitmask, uint8_t offline_cpu_socket)
       void rte_efd_free (struct rte_efd_table *table)
       struct rte_efd_table * rte_efd_find_existing (const char *name)
       int rte_efd_update (struct rte_efd_table *table, unsigned int socket_id, const void *key, efd_value_t
           value)
       int rte_efd_delete (struct rte_efd_table *table, unsigned int socket_id, const void *key, efd_value_t
           *prev_value)
       efd_value_t rte_efd_lookup (const struct rte_efd_table *table, unsigned int socket_id, const void *key)
       void rte_efd_lookup_bulk (const struct rte_efd_table *table, unsigned int socket_id, int num_keys, const
           void **key_list, efd_value_t *value_list)

Detailed Description

       RTE EFD Table

       Definition in file rte_efd.h.

Macro Definition Documentation

   #define RTE_EFD_VALUE_NUM_BITS   (8)
       !!! This parameter should be adjusted for your application !!!

       This parameter adjusts the number of bits of value that can be stored in the table. For example, setting
       the number of bits to 3 will allow storing 8 values in the table (between 0 and 7).

       This number directly affects the performance of both lookups and insertion. In general, performance
       decreases as more bits are stored in the table.

       This number is directly proportional to the size of the online region used for lookups.

       Note that due to the way the CPU operates on memory, best lookup performance will be achieved when
       RTE_EFD_VALUE_NUM_BITS is a multiple of 8. These values align the hash indexes on 16-byte boundaries. The
       greatest performance drop is moving from 8->9 bits, 16->17 bits, etc.

       This value must be between 1 and 32

       Definition at line 65 of file rte_efd.h.

   #define RTE_EFD_BURST_MAX   (32)
       Maximum number of keys that can be looked up in one call to efd_lookup_bulk

       Definition at line 99 of file rte_efd.h.

   #define RTE_EFD_NAMESIZE   32
       Maximum number of characters in efd name.

       Definition at line 103 of file rte_efd.h.

Function Documentation

   struct rte_efd_table * rte_efd_create (const char * name, uint32_t max_num_rules, uint32_t key_len, uint64_t
       online_cpu_socket_bitmask, uint8_t offline_cpu_socket)
       Creates an EFD table with a single offline region and multiple per-socket internally-managed copies of
       the online table used for lookups

       Parameters
           name EFD table name
           max_num_rules Minimum number of rules the table should be sized to hold. Will be rounded up to the
           next smallest valid table size
           key_len Length of the key
           online_cpu_socket_bitmask Bitmask specifying which sockets should get a copy of the online table. LSB
           = socket 0, etc.
           offline_cpu_socket Identifies the socket where the offline table will be allocated (and most
           efficiently accessed in the case of updates/insertions)

       Returns
           EFD table, or NULL if table allocation failed or the bitmask is invalid

   void rte_efd_free (struct rte_efd_table * table)
       Releases the resources from an EFD table

       Parameters
           table Pointer to table allocated with rte_efd_create(). If table is NULL, no operation is performed.

   struct rte_efd_table * rte_efd_find_existing (const char * name)
       Find an existing EFD table object and return a pointer to it.

       Parameters
           name Name of the EFD table as passed to rte_efd_create()

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

           • ENOENT - value not available for return

   int  rte_efd_update  (struct  rte_efd_table  *  table,  unsigned int socket_id, const void * key, efd_value_t
       value)
       Computes an updated table entry for the supplied key/value pair. The update is then  immediately  applied
       to the provided table and all socket-local copies of the chunks are updated. This operation is not multi-
       thread safe and should only be called one from thread.

       Parameters
           table EFD table to reference
           socket_id Socket ID to use to lookup existing value (ideally caller's socket id)
           key EFD table key to modify
           value Value to associate with the key

       Returns
           RTE_EFD_UPDATE_WARN_GROUP_FULL  Operation  is insert, and the last available space in the key's group
           was just used Future inserts may fail as groups fill up This  operation  was  still  successful,  and
           entry  contains a valid update RTE_EFD_UPDATE_FAILED Either the EFD failed to find a suitable perfect
           hash or the group was full This is a fatal error, and the table is  now  in  an  indeterminate  state
           RTE_EFD_UPDATE_NO_CHANGE Operation resulted in no change to the table (same value already exists) 0 -
           success

   int  rte_efd_delete  (struct  rte_efd_table  * table, unsigned int socket_id, const void * key, efd_value_t *
       prev_value)
       Removes any value currently associated with the specified key from the table This operation is not multi-
       thread safe and should only be called from one thread.

       Parameters
           table EFD table to reference
           socket_id Socket ID to use to lookup existing value (ideally caller's socket id)
           key EFD table key to delete
           prev_value If not NULL, will store the previous value here before deleting it

       Returns
           0 - successfully found and deleted the key nonzero otherwise

   efd_value_t rte_efd_lookup (const struct rte_efd_table * table, unsigned int socket_id, const void * key)
       Looks up the value associated with a key This operation is multi-thread safe.

       NOTE: Lookups will always succeed - this is a property of using a perfect hash table.  If  the  specified
       key  was  never  inserted,  a  pseudorandom answer will be returned. There is no way to know based on the
       lookup if the key was ever inserted originally, so this must be tracked elsewhere.

       Parameters
           table EFD table to reference
           socket_id Socket ID to use to lookup existing value (ideally caller's socket id)
           key EFD table key to look up

       Returns
           Value associated with the key, or random junk if they key was never inserted

   void rte_efd_lookup_bulk (const struct rte_efd_table * table, unsigned int  socket_id,  int  num_keys,  const
       void ** key_list, efd_value_t * value_list)
       Looks up the value associated with several keys. This operation is multi-thread safe.

       NOTE:  Lookups  will  always succeed - this is a property of using a perfect hash table. If the specified
       key was never inserted, a pseudorandom answer will be returned. There is no way  to  know  based  on  the
       lookup if the key was ever inserted originally, so this must be tracked elsewhere.

       Parameters
           table EFD table to reference
           socket_id Socket ID to use to lookup existing value (ideally caller's socket id)
           num_keys Number of keys in the key_list array, must be less than RTE_EFD_BURST_MAX
           key_list Array of num_keys pointers which point to keys to look up
           value_list Array of size num_keys where lookup values will be stored

Author

       Generated automatically by Doxygen for DPDK from the source code.

DPDK                                             Version 24.11.2                                    rte_efd.h(3)