|
DPDK
21.11.8
|
Go to the source code of this file.
Data Structures | |
| struct | rte_table_stats |
| struct | rte_table_ops |
Typedefs | |
| typedef void *(* | rte_table_op_create) (void *params, int socket_id, uint32_t entry_size) |
| typedef int(* | rte_table_op_free) (void *table) |
| typedef int(* | rte_table_op_entry_add) (void *table, void *key, void *entry, int *key_found, void **entry_ptr) |
| typedef int(* | rte_table_op_entry_delete) (void *table, void *key, int *key_found, void *entry) |
| typedef int(* | rte_table_op_entry_add_bulk) (void *table, void **keys, void **entries, uint32_t n_keys, int *key_found, void **entries_ptr) |
| typedef int(* | rte_table_op_entry_delete_bulk) (void *table, void **keys, uint32_t n_keys, int *key_found, void **entries) |
| typedef int(* | rte_table_op_lookup) (void *table, struct rte_mbuf **pkts, uint64_t pkts_mask, uint64_t *lookup_hit_mask, void **entries) |
| typedef int(* | rte_table_op_stats_read) (void *table, struct rte_table_stats *stats, int clear) |
RTE Table
This tool is part of the DPDK Packet Framework tool suite and provides a standard interface to implement different types of lookup tables for data plane processing.
Virtually any search algorithm that can uniquely associate data to a lookup key can be fitted under this lookup table abstraction. For the flow table use-case, the lookup key is an n-tuple of packet fields that uniquely identifies a traffic flow, while data represents actions and action meta-data associated with the same traffic flow.
Definition in file rte_table.h.
| typedef void*(* rte_table_op_create) (void *params, int socket_id, uint32_t entry_size) |
Lookup table create
| params | Parameters for lookup table creation. The underlying data structure is different for each lookup table type. |
| socket_id | CPU socket ID (e.g. for memory allocation purpose) |
| entry_size | Data size of each lookup table entry (measured in bytes) |
Definition at line 52 of file rte_table.h.
| typedef int(* rte_table_op_free) (void *table) |
Lookup table free
| table | Handle to lookup table instance |
Definition at line 63 of file rte_table.h.
| typedef int(* rte_table_op_entry_add) (void *table, void *key, void *entry, int *key_found, void **entry_ptr) |
Lookup table entry add
| table | Handle to lookup table instance |
| key | Lookup key |
| entry | Data to be associated with the current key. This parameter has to point to a valid memory buffer where the first entry_size bytes (table create parameter) are populated with the data. |
| key_found | After successful invocation, *key_found is set to a value different than 0 if the current key is already present in the table and to 0 if not. This pointer has to be set to a valid memory location before the table entry add function is called. |
| entry_ptr | After successful invocation, *entry_ptr stores the handle to the table entry containing the data associated with the current key. This handle can be used to perform further read-write accesses to this entry. This handle is valid until the key is deleted from the table or the same key is re-added to the table, typically to associate it with different data. This pointer has to be set to a valid memory location before the function is called. |
Definition at line 92 of file rte_table.h.
| typedef int(* rte_table_op_entry_delete) (void *table, void *key, int *key_found, void *entry) |
Lookup table entry delete
| table | Handle to lookup table instance |
| key | Lookup key |
| key_found | After successful invocation, *key_found is set to a value different than 0 if the current key was present in the table before the delete operation was performed and to 0 if not. This pointer has to be set to a valid memory location before the table entry delete function is called. |
| entry | After successful invocation, if the key is found in the table (*key found is different than 0 after function call is completed) and entry points to a valid buffer (entry is set to a value different than NULL before the function is called), then the first entry_size bytes (table create parameter) in *entry store a copy of table entry that contained the data associated with the current key before the key was deleted. |
Definition at line 121 of file rte_table.h.
| typedef int(* rte_table_op_entry_add_bulk) (void *table, void **keys, void **entries, uint32_t n_keys, int *key_found, void **entries_ptr) |
Lookup table entry add bulk
| table | Handle to lookup table instance |
| keys | Array containing lookup keys |
| entries | Array containing data to be associated with each key. Every item in the array has to point to a valid memory buffer where the first entry_size bytes (table create parameter) are populated with the data. |
| n_keys | Number of keys to add |
| key_found | After successful invocation, key_found for every item in the array is set to a value different than 0 if the current key is already present in the table and to 0 if not. This pointer has to be set to a valid memory location before the table entry add function is called. |
| entries_ptr | After successful invocation, array *entries_ptr stores the handle to the table entry containing the data associated with every key. This handle can be used to perform further read-write accesses to this entry. This handle is valid until the key is deleted from the table or the same key is re-added to the table, typically to associate it with different data. This pointer has to be set to a valid memory location before the function is called. |
Definition at line 156 of file rte_table.h.
| typedef int(* rte_table_op_entry_delete_bulk) (void *table, void **keys, uint32_t n_keys, int *key_found, void **entries) |
Lookup table entry delete bulk
| table | Handle to lookup table instance |
| keys | Array containing lookup keys |
| n_keys | Number of keys to delete |
| key_found | After successful invocation, key_found for every item in the array is set to a value different than 0if the current key was present in the table before the delete operation was performed and to 0 if not. This pointer has to be set to a valid memory location before the table entry delete function is called. |
| entries | If entries pointer is NULL, this pointer is ignored for every entry found. Else, after successful invocation, if specific key is found in the table (key_found is different than 0 for this item after function call is completed) and item of entry array points to a valid buffer (entry is set to a value different than NULL before the function is called), then the first entry_size bytes (table create parameter) in *entry store a copy of table entry that contained the data associated with the current key before the key was deleted. |
Definition at line 191 of file rte_table.h.
| typedef int(* rte_table_op_lookup) (void *table, struct rte_mbuf **pkts, uint64_t pkts_mask, uint64_t *lookup_hit_mask, void **entries) |
Lookup table lookup
| table | Handle to lookup table instance |
| pkts | Burst of input packets specified as array of up to 64 pointers to struct rte_mbuf |
| pkts_mask | 64-bit bitmask specifying which packets in the input burst are valid. When pkts_mask bit n is set, then element n of pkts array is pointing to a valid packet. Otherwise, element n of pkts array does not point to a valid packet, therefore it will not be accessed. |
| lookup_hit_mask | Once the table lookup operation is completed, this 64-bit bitmask specifies which of the valid packets in the input burst resulted in lookup hit. For each valid input packet (pkts_mask bit n is set), the following are true on lookup hit: lookup_hit_mask bit n is set, element n of entries array is valid and it points to the lookup table entry that was hit. For each valid input packet (pkts_mask bit n is set), the following are true on lookup miss: lookup_hit_mask bit n is not set and element n of entries array is not valid. |
| entries | Once the table lookup operation is completed, this array provides the lookup table entries that were hit, as described above. It is required that this array is always pre-allocated by the caller of this function with exactly 64 elements. The implementation is allowed to speculatively modify the elements of this array, so elements marked as invalid in lookup_hit_mask once the table lookup operation is completed might have been modified by this function. |
Definition at line 231 of file rte_table.h.
| typedef int(* rte_table_op_stats_read) (void *table, struct rte_table_stats *stats, int clear) |
Lookup table stats read
| table | Handle to lookup table instance |
| stats | Handle to table stats struct to copy data |
| clear | Flag indicating that stats should be cleared after read |
Definition at line 251 of file rte_table.h.
1.8.13