Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright(c) 2010-2017 Intel Corporation
3 : : */
4 : :
5 : : #include <stdalign.h>
6 : : #include <stdio.h>
7 : : #include <string.h>
8 : :
9 : : #include <eal_export.h>
10 : : #include <rte_common.h>
11 : : #include <rte_malloc.h>
12 : : #include <rte_log.h>
13 : :
14 : : #include "rte_table_hash_cuckoo.h"
15 : :
16 : : #include "table_log.h"
17 : :
18 : : #ifdef RTE_TABLE_STATS_COLLECT
19 : :
20 : : #define RTE_TABLE_HASH_CUCKOO_STATS_PKTS_IN_ADD(table, val) \
21 : : (table->stats.n_pkts_in += val)
22 : : #define RTE_TABLE_HASH_CUCKOO_STATS_PKTS_LOOKUP_MISS(table, val) \
23 : : (table->stats.n_pkts_lookup_miss += val)
24 : :
25 : : #else
26 : :
27 : : #define RTE_TABLE_HASH_CUCKOO_STATS_PKTS_IN_ADD(table, val)
28 : : #define RTE_TABLE_HASH_CUCKOO_STATS_PKTS_LOOKUP_MISS(table, val)
29 : :
30 : : #endif
31 : :
32 : :
33 : : struct rte_table_hash {
34 : : struct rte_table_stats stats;
35 : :
36 : : /* Input parameters */
37 : : uint32_t key_size;
38 : : uint32_t entry_size;
39 : : uint32_t n_keys;
40 : : rte_hash_function f_hash;
41 : : uint32_t seed;
42 : : uint32_t key_offset;
43 : :
44 : : /* cuckoo hash table object */
45 : : struct rte_hash *h_table;
46 : :
47 : : /* Lookup table */
48 : : alignas(RTE_CACHE_LINE_SIZE) uint8_t memory[];
49 : : };
50 : :
51 : : static int
52 : 11 : check_params_create_hash_cuckoo(struct rte_table_hash_cuckoo_params *params)
53 : : {
54 [ + + ]: 11 : if (params == NULL) {
55 : 1 : TABLE_LOG(ERR, "NULL Input Parameters.");
56 : 1 : return -EINVAL;
57 : : }
58 : :
59 [ + + ]: 10 : if (params->name == NULL) {
60 : 1 : TABLE_LOG(ERR, "Table name is NULL.");
61 : 1 : return -EINVAL;
62 : : }
63 : :
64 [ + + ]: 9 : if (params->key_size == 0) {
65 : 2 : TABLE_LOG(ERR, "Invalid key_size.");
66 : 2 : return -EINVAL;
67 : : }
68 : :
69 [ + + ]: 7 : if (params->n_keys == 0) {
70 : 2 : TABLE_LOG(ERR, "Invalid n_keys.");
71 : 2 : return -EINVAL;
72 : : }
73 : :
74 [ + + ]: 5 : if (params->f_hash == NULL) {
75 : 2 : TABLE_LOG(ERR, "f_hash is NULL.");
76 : 2 : return -EINVAL;
77 : : }
78 : :
79 : : return 0;
80 : : }
81 : :
82 : : static void *
83 : 11 : rte_table_hash_cuckoo_create(void *params,
84 : : int socket_id,
85 : : uint32_t entry_size)
86 : : {
87 : : struct rte_table_hash_cuckoo_params *p = params;
88 : : struct rte_hash *h_table;
89 : : struct rte_table_hash *t;
90 : : uint32_t total_size;
91 : :
92 : : /* Check input parameters */
93 [ + + ]: 11 : if (check_params_create_hash_cuckoo(params))
94 : : return NULL;
95 : :
96 : : /* Memory allocation */
97 : 3 : total_size = sizeof(struct rte_table_hash) +
98 : 3 : RTE_CACHE_LINE_ROUNDUP(p->n_keys * entry_size);
99 : :
100 : 3 : t = rte_zmalloc_socket(p->name, total_size, RTE_CACHE_LINE_SIZE, socket_id);
101 [ - + ]: 3 : if (t == NULL) {
102 : 0 : TABLE_LOG(ERR,
103 : : "%s: Cannot allocate %u bytes for cuckoo hash table %s",
104 : : __func__, total_size, p->name);
105 : 0 : return NULL;
106 : : }
107 : :
108 : : /* Create cuckoo hash table */
109 : 3 : struct rte_hash_parameters hash_cuckoo_params = {
110 : 3 : .entries = p->n_keys,
111 : 3 : .key_len = p->key_size,
112 : 3 : .hash_func = p->f_hash,
113 : 3 : .hash_func_init_val = p->seed,
114 : : .socket_id = socket_id,
115 : 3 : .name = p->name
116 : : };
117 : :
118 : 3 : h_table = rte_hash_find_existing(p->name);
119 [ + - ]: 3 : if (h_table == NULL) {
120 : 3 : h_table = rte_hash_create(&hash_cuckoo_params);
121 [ - + ]: 3 : if (h_table == NULL) {
122 : 0 : TABLE_LOG(ERR,
123 : : "%s: failed to create cuckoo hash table %s",
124 : : __func__, p->name);
125 : 0 : rte_free(t);
126 : 0 : return NULL;
127 : : }
128 : : }
129 : :
130 : : /* initialize the cuckoo hash parameters */
131 : 3 : t->key_size = p->key_size;
132 : 3 : t->entry_size = entry_size;
133 : 3 : t->n_keys = p->n_keys;
134 : 3 : t->f_hash = p->f_hash;
135 : 3 : t->seed = p->seed;
136 : 3 : t->key_offset = p->key_offset;
137 : 3 : t->h_table = h_table;
138 : :
139 : 3 : TABLE_LOG(INFO,
140 : : "%s: Cuckoo hash table %s memory footprint is %u bytes",
141 : : __func__, p->name, total_size);
142 : 3 : return t;
143 : : }
144 : :
145 : : static int
146 : 4 : rte_table_hash_cuckoo_free(void *table) {
147 : : struct rte_table_hash *t = table;
148 : :
149 [ + + ]: 4 : if (table == NULL)
150 : : return -EINVAL;
151 : :
152 : 3 : rte_hash_free(t->h_table);
153 : 3 : rte_free(t);
154 : :
155 : 3 : return 0;
156 : : }
157 : :
158 : : static int
159 : 8 : rte_table_hash_cuckoo_entry_add(void *table, void *key, void *entry,
160 : : int *key_found, void **entry_ptr)
161 : : {
162 : : struct rte_table_hash *t = table;
163 : : int pos = 0;
164 : :
165 : : /* Check input parameters */
166 : 8 : if ((table == NULL) ||
167 [ + + ]: 8 : (key == NULL) ||
168 : 6 : (entry == NULL) ||
169 [ + + + - ]: 6 : (key_found == NULL) ||
170 : : (entry_ptr == NULL))
171 : : return -EINVAL;
172 : :
173 : : /* Find Existing entries */
174 : 5 : pos = rte_hash_lookup(t->h_table, key);
175 [ + + ]: 5 : if (pos >= 0) {
176 : : uint8_t *existing_entry;
177 : :
178 : 2 : *key_found = 1;
179 : 2 : existing_entry = &t->memory[pos * t->entry_size];
180 : 2 : memcpy(existing_entry, entry, t->entry_size);
181 : 2 : *entry_ptr = existing_entry;
182 : :
183 : 2 : return 0;
184 : : }
185 : :
186 [ + - ]: 3 : if (pos == -ENOENT) {
187 : : /* Entry not found. Adding new entry */
188 : : uint8_t *new_entry;
189 : :
190 : 3 : pos = rte_hash_add_key(t->h_table, key);
191 [ + - ]: 3 : if (pos < 0)
192 : : return pos;
193 : :
194 : 3 : new_entry = &t->memory[pos * t->entry_size];
195 : 3 : memcpy(new_entry, entry, t->entry_size);
196 : :
197 : 3 : *key_found = 0;
198 : 3 : *entry_ptr = new_entry;
199 : 3 : return 0;
200 : : }
201 : :
202 : : return pos;
203 : : }
204 : :
205 : : static int
206 : 5 : rte_table_hash_cuckoo_entry_delete(void *table, void *key,
207 : : int *key_found, void *entry)
208 : : {
209 : : struct rte_table_hash *t = table;
210 : : int pos = 0;
211 : :
212 : : /* Check input parameters */
213 : 5 : if ((table == NULL) ||
214 [ + + + - ]: 5 : (key == NULL) ||
215 : : (key_found == NULL))
216 : : return -EINVAL;
217 : :
218 : 3 : pos = rte_hash_del_key(t->h_table, key);
219 [ + + ]: 3 : if (pos >= 0) {
220 : 2 : *key_found = 1;
221 : 2 : uint8_t *entry_ptr = &t->memory[pos * t->entry_size];
222 : :
223 [ - + ]: 2 : if (entry)
224 : 0 : memcpy(entry, entry_ptr, t->entry_size);
225 : :
226 : 2 : memset(&t->memory[pos * t->entry_size], 0, t->entry_size);
227 : 2 : return 0;
228 : : }
229 : :
230 : 1 : *key_found = 0;
231 : 1 : return pos;
232 : : }
233 : :
234 : : static int
235 [ + - ]: 7 : rte_table_hash_cuckoo_lookup(void *table,
236 : : struct rte_mbuf **pkts,
237 : : uint64_t pkts_mask,
238 : : uint64_t *lookup_hit_mask,
239 : : void **entries)
240 : : {
241 : : struct rte_table_hash *t = table;
242 : : uint64_t pkts_mask_out = 0;
243 : : uint32_t i;
244 : :
245 : : __rte_unused uint32_t n_pkts_in = rte_popcount64(pkts_mask);
246 : :
247 : : RTE_TABLE_HASH_CUCKOO_STATS_PKTS_IN_ADD(t, n_pkts_in);
248 : :
249 [ + - ]: 7 : if ((pkts_mask & (pkts_mask + 1)) == 0) {
250 : : const uint8_t *keys[RTE_PORT_IN_BURST_SIZE_MAX];
251 : : int32_t positions[RTE_PORT_IN_BURST_SIZE_MAX], status;
252 : :
253 : : /* Keys for bulk lookup */
254 [ + + ]: 273 : for (i = 0; i < n_pkts_in; i++)
255 : 266 : keys[i] = RTE_MBUF_METADATA_UINT8_PTR(pkts[i],
256 : : t->key_offset);
257 : :
258 : : /* Bulk Lookup */
259 : 7 : status = rte_hash_lookup_bulk(t->h_table,
260 : : (const void **) keys,
261 : : n_pkts_in,
262 : : positions);
263 [ + - ]: 7 : if (status == 0) {
264 [ + + ]: 273 : for (i = 0; i < n_pkts_in; i++) {
265 [ + + ]: 266 : if (likely(positions[i] >= 0)) {
266 : 158 : uint64_t pkt_mask = 1LLU << i;
267 : :
268 : 158 : entries[i] = &t->memory[positions[i]
269 : 158 : * t->entry_size];
270 : 158 : pkts_mask_out |= pkt_mask;
271 : : }
272 : : }
273 : : }
274 : : } else
275 [ # # ]: 0 : for (i = 0; i < (uint32_t)(RTE_PORT_IN_BURST_SIZE_MAX
276 : 0 : - rte_clz64(pkts_mask)); i++) {
277 : 0 : uint64_t pkt_mask = 1LLU << i;
278 : :
279 [ # # ]: 0 : if (pkt_mask & pkts_mask) {
280 : 0 : struct rte_mbuf *pkt = pkts[i];
281 : 0 : uint8_t *key = RTE_MBUF_METADATA_UINT8_PTR(pkt,
282 : : t->key_offset);
283 : : int pos;
284 : :
285 : 0 : pos = rte_hash_lookup(t->h_table, key);
286 [ # # ]: 0 : if (likely(pos >= 0)) {
287 : 0 : entries[i] = &t->memory[pos
288 : 0 : * t->entry_size];
289 : 0 : pkts_mask_out |= pkt_mask;
290 : : }
291 : : }
292 : : }
293 : :
294 : 7 : *lookup_hit_mask = pkts_mask_out;
295 : : RTE_TABLE_HASH_CUCKOO_STATS_PKTS_LOOKUP_MISS(t,
296 : : n_pkts_in - rte_popcount64(pkts_mask_out));
297 : :
298 : 7 : return 0;
299 : :
300 : : }
301 : :
302 : : static int
303 : 0 : rte_table_hash_cuckoo_stats_read(void *table, struct rte_table_stats *stats,
304 : : int clear)
305 : : {
306 : : struct rte_table_hash *t = table;
307 : :
308 [ # # ]: 0 : if (stats != NULL)
309 : 0 : memcpy(stats, &t->stats, sizeof(t->stats));
310 : :
311 [ # # ]: 0 : if (clear)
312 : 0 : memset(&t->stats, 0, sizeof(t->stats));
313 : :
314 : 0 : return 0;
315 : : }
316 : :
317 : : RTE_EXPORT_SYMBOL(rte_table_hash_cuckoo_ops)
318 : : struct rte_table_ops rte_table_hash_cuckoo_ops = {
319 : : .f_create = rte_table_hash_cuckoo_create,
320 : : .f_free = rte_table_hash_cuckoo_free,
321 : : .f_add = rte_table_hash_cuckoo_entry_add,
322 : : .f_delete = rte_table_hash_cuckoo_entry_delete,
323 : : .f_add_bulk = NULL,
324 : : .f_delete_bulk = NULL,
325 : : .f_lookup = rte_table_hash_cuckoo_lookup,
326 : : .f_stats = rte_table_hash_cuckoo_stats_read,
327 : : };
|
