4 * Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
11 * * Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
17 * * Neither the name of Intel Corporation nor the names of its
18 * contributors may be used to endorse or promote products derived
19 * from this software without specific prior written permission.
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
27 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
39 #include <rte_ethdev.h>
40 #include <rte_ether.h>
42 #include <rte_byteorder.h>
44 #include <rte_port_ring.h>
45 #include <rte_table_hash.h>
46 #include <rte_pipeline.h>
51 translate_options(uint32_t *special, uint32_t *ext, uint32_t *key_size)
53 switch (app.pipeline_type) {
54 case e_APP_PIPELINE_HASH_KEY8_EXT:
55 *special = 0; *ext = 1; *key_size = 8; return;
56 case e_APP_PIPELINE_HASH_KEY8_LRU:
57 *special = 0; *ext = 0; *key_size = 8; return;
58 case e_APP_PIPELINE_HASH_KEY16_EXT:
59 *special = 0; *ext = 1; *key_size = 16; return;
60 case e_APP_PIPELINE_HASH_KEY16_LRU:
61 *special = 0; *ext = 0; *key_size = 16; return;
62 case e_APP_PIPELINE_HASH_KEY32_EXT:
63 *special = 0; *ext = 1; *key_size = 32; return;
64 case e_APP_PIPELINE_HASH_KEY32_LRU:
65 *special = 0; *ext = 0; *key_size = 32; return;
67 case e_APP_PIPELINE_HASH_SPEC_KEY8_EXT:
68 *special = 1; *ext = 1; *key_size = 8; return;
69 case e_APP_PIPELINE_HASH_SPEC_KEY8_LRU:
70 *special = 1; *ext = 0; *key_size = 8; return;
71 case e_APP_PIPELINE_HASH_SPEC_KEY16_EXT:
72 *special = 1; *ext = 1; *key_size = 16; return;
73 case e_APP_PIPELINE_HASH_SPEC_KEY16_LRU:
74 *special = 1; *ext = 0; *key_size = 16; return;
75 case e_APP_PIPELINE_HASH_SPEC_KEY32_EXT:
76 *special = 1; *ext = 1; *key_size = 32; return;
77 case e_APP_PIPELINE_HASH_SPEC_KEY32_LRU:
78 *special = 1; *ext = 0; *key_size = 32; return;
81 rte_panic("Invalid hash table type or key size\n");
85 app_main_loop_worker_pipeline_hash(void) {
86 struct rte_pipeline_params pipeline_params = {
88 .socket_id = rte_socket_id(),
91 struct rte_pipeline *p;
92 uint32_t port_in_id[APP_MAX_PORTS];
93 uint32_t port_out_id[APP_MAX_PORTS];
96 uint32_t special, ext, key_size;
98 translate_options(&special, &ext, &key_size);
100 RTE_LOG(INFO, USER1, "Core %u is doing work "
101 "(pipeline with hash table, %s, %s, %d-byte key)\n",
103 special ? "specialized" : "non-specialized",
104 ext ? "extendible bucket" : "LRU",
107 /* Pipeline configuration */
108 p = rte_pipeline_create(&pipeline_params);
110 rte_panic("Unable to configure the pipeline\n");
112 /* Input port configuration */
113 for (i = 0; i < app.n_ports; i++) {
114 struct rte_port_ring_reader_params port_ring_params = {
115 .ring = app.rings_rx[i],
118 struct rte_pipeline_port_in_params port_params = {
119 .ops = &rte_port_ring_reader_ops,
120 .arg_create = (void *) &port_ring_params,
123 .burst_size = app.burst_size_worker_read,
126 if (rte_pipeline_port_in_create(p, &port_params,
128 rte_panic("Unable to configure input port for "
132 /* Output port configuration */
133 for (i = 0; i < app.n_ports; i++) {
134 struct rte_port_ring_writer_params port_ring_params = {
135 .ring = app.rings_tx[i],
136 .tx_burst_sz = app.burst_size_worker_write,
139 struct rte_pipeline_port_out_params port_params = {
140 .ops = &rte_port_ring_writer_ops,
141 .arg_create = (void *) &port_ring_params,
143 .f_action_bulk = NULL,
147 if (rte_pipeline_port_out_create(p, &port_params,
149 rte_panic("Unable to configure output port for "
153 /* Table configuration */
154 switch (app.pipeline_type) {
155 case e_APP_PIPELINE_HASH_KEY8_EXT:
156 case e_APP_PIPELINE_HASH_KEY16_EXT:
157 case e_APP_PIPELINE_HASH_KEY32_EXT:
159 struct rte_table_hash_ext_params table_hash_params = {
160 .key_size = key_size,
162 .n_buckets = 1 << 22,
163 .n_buckets_ext = 1 << 21,
166 .signature_offset = APP_METADATA_OFFSET(0),
167 .key_offset = APP_METADATA_OFFSET(32),
170 struct rte_pipeline_table_params table_params = {
171 .ops = &rte_table_hash_ext_ops,
172 .arg_create = &table_hash_params,
173 .f_action_hit = NULL,
174 .f_action_miss = NULL,
176 .action_data_size = 0,
179 if (rte_pipeline_table_create(p, &table_params, &table_id))
180 rte_panic("Unable to configure the hash table\n");
184 case e_APP_PIPELINE_HASH_KEY8_LRU:
185 case e_APP_PIPELINE_HASH_KEY16_LRU:
186 case e_APP_PIPELINE_HASH_KEY32_LRU:
188 struct rte_table_hash_lru_params table_hash_params = {
189 .key_size = key_size,
191 .n_buckets = 1 << 22,
194 .signature_offset = 0,
198 struct rte_pipeline_table_params table_params = {
199 .ops = &rte_table_hash_lru_ops,
200 .arg_create = &table_hash_params,
201 .f_action_hit = NULL,
202 .f_action_miss = NULL,
204 .action_data_size = 0,
207 if (rte_pipeline_table_create(p, &table_params, &table_id))
208 rte_panic("Unable to configure the hash table\n");
212 case e_APP_PIPELINE_HASH_SPEC_KEY8_EXT:
214 struct rte_table_hash_key8_ext_params table_hash_params = {
215 .n_entries = 1 << 24,
216 .n_entries_ext = 1 << 23,
217 .signature_offset = APP_METADATA_OFFSET(0),
218 .key_offset = APP_METADATA_OFFSET(32),
224 struct rte_pipeline_table_params table_params = {
225 .ops = &rte_table_hash_key8_ext_ops,
226 .arg_create = &table_hash_params,
227 .f_action_hit = NULL,
228 .f_action_miss = NULL,
230 .action_data_size = 0,
233 if (rte_pipeline_table_create(p, &table_params, &table_id))
234 rte_panic("Unable to configure the hash table\n");
238 case e_APP_PIPELINE_HASH_SPEC_KEY8_LRU:
240 struct rte_table_hash_key8_lru_params table_hash_params = {
241 .n_entries = 1 << 24,
242 .signature_offset = APP_METADATA_OFFSET(0),
243 .key_offset = APP_METADATA_OFFSET(32),
249 struct rte_pipeline_table_params table_params = {
250 .ops = &rte_table_hash_key8_lru_ops,
251 .arg_create = &table_hash_params,
252 .f_action_hit = NULL,
253 .f_action_miss = NULL,
255 .action_data_size = 0,
258 if (rte_pipeline_table_create(p, &table_params, &table_id))
259 rte_panic("Unable to configure the hash table\n");
263 case e_APP_PIPELINE_HASH_SPEC_KEY16_EXT:
265 struct rte_table_hash_key16_ext_params table_hash_params = {
266 .n_entries = 1 << 24,
267 .n_entries_ext = 1 << 23,
268 .signature_offset = APP_METADATA_OFFSET(0),
269 .key_offset = APP_METADATA_OFFSET(32),
275 struct rte_pipeline_table_params table_params = {
276 .ops = &rte_table_hash_key16_ext_ops,
277 .arg_create = &table_hash_params,
278 .f_action_hit = NULL,
279 .f_action_miss = NULL,
281 .action_data_size = 0,
284 if (rte_pipeline_table_create(p, &table_params, &table_id))
285 rte_panic("Unable to configure the hash table)\n");
289 case e_APP_PIPELINE_HASH_SPEC_KEY16_LRU:
291 struct rte_table_hash_key16_lru_params table_hash_params = {
292 .n_entries = 1 << 24,
293 .signature_offset = APP_METADATA_OFFSET(0),
294 .key_offset = APP_METADATA_OFFSET(32),
300 struct rte_pipeline_table_params table_params = {
301 .ops = &rte_table_hash_key16_lru_ops,
302 .arg_create = &table_hash_params,
303 .f_action_hit = NULL,
304 .f_action_miss = NULL,
306 .action_data_size = 0,
309 if (rte_pipeline_table_create(p, &table_params, &table_id))
310 rte_panic("Unable to configure the hash table\n");
314 case e_APP_PIPELINE_HASH_SPEC_KEY32_EXT:
316 struct rte_table_hash_key32_ext_params table_hash_params = {
317 .n_entries = 1 << 24,
318 .n_entries_ext = 1 << 23,
319 .signature_offset = APP_METADATA_OFFSET(0),
320 .key_offset = APP_METADATA_OFFSET(32),
325 struct rte_pipeline_table_params table_params = {
326 .ops = &rte_table_hash_key32_ext_ops,
327 .arg_create = &table_hash_params,
328 .f_action_hit = NULL,
329 .f_action_miss = NULL,
331 .action_data_size = 0,
334 if (rte_pipeline_table_create(p, &table_params, &table_id))
335 rte_panic("Unable to configure the hash table\n");
340 case e_APP_PIPELINE_HASH_SPEC_KEY32_LRU:
342 struct rte_table_hash_key32_lru_params table_hash_params = {
343 .n_entries = 1 << 24,
344 .signature_offset = APP_METADATA_OFFSET(0),
345 .key_offset = APP_METADATA_OFFSET(32),
350 struct rte_pipeline_table_params table_params = {
351 .ops = &rte_table_hash_key32_lru_ops,
352 .arg_create = &table_hash_params,
353 .f_action_hit = NULL,
354 .f_action_miss = NULL,
356 .action_data_size = 0,
359 if (rte_pipeline_table_create(p, &table_params, &table_id))
360 rte_panic("Unable to configure the hash table\n");
365 rte_panic("Invalid hash table type or key size\n");
368 /* Interconnecting ports and tables */
369 for (i = 0; i < app.n_ports; i++)
370 if (rte_pipeline_port_in_connect_to_table(p, port_in_id[i],
372 rte_panic("Unable to connect input port %u to "
373 "table %u\n", port_in_id[i], table_id);
375 /* Add entries to tables */
376 for (i = 0; i < (1 << 24); i++) {
377 struct rte_pipeline_table_entry entry = {
378 .action = RTE_PIPELINE_ACTION_PORT,
379 {.port_id = port_out_id[i & (app.n_ports - 1)]},
381 struct rte_pipeline_table_entry *entry_ptr;
383 uint32_t *k32 = (uint32_t *) key;
384 int key_found, status;
386 memset(key, 0, sizeof(key));
387 k32[0] = rte_be_to_cpu_32(i);
389 status = rte_pipeline_table_entry_add(p, table_id, key, &entry,
390 &key_found, &entry_ptr);
392 rte_panic("Unable to add entry to table %u (%d)\n",
396 /* Enable input ports */
397 for (i = 0; i < app.n_ports; i++)
398 if (rte_pipeline_port_in_enable(p, port_in_id[i]))
399 rte_panic("Unable to enable input port %u\n",
402 /* Check pipeline consistency */
403 if (rte_pipeline_check(p) < 0)
404 rte_panic("Pipeline consistency check failed\n");
414 if ((i & APP_FLUSH) == 0)
415 rte_pipeline_flush(p);
422 __attribute__((unused)) uint32_t key_size,
423 __attribute__((unused)) uint64_t seed)
425 uint32_t *k32 = (uint32_t *) key;
426 uint32_t ip_dst = rte_be_to_cpu_32(k32[0]);
427 uint64_t signature = (ip_dst >> 2) | ((ip_dst & 0x3) << 30);
433 app_main_loop_rx_metadata(void) {
437 RTE_LOG(INFO, USER1, "Core %u is doing RX (with meta-data)\n",
440 for (i = 0; ; i = ((i + 1) & (app.n_ports - 1))) {
443 n_mbufs = rte_eth_rx_burst(
447 app.burst_size_rx_read);
452 for (j = 0; j < n_mbufs; j++) {
454 uint8_t *m_data, *key;
455 struct ipv4_hdr *ip_hdr;
456 struct ipv6_hdr *ipv6_hdr;
459 uint32_t *signature, *k32;
461 m = app.mbuf_rx.array[j];
462 m_data = rte_pktmbuf_mtod(m, uint8_t *);
463 signature = RTE_MBUF_METADATA_UINT32_PTR(m,
464 APP_METADATA_OFFSET(0));
465 key = RTE_MBUF_METADATA_UINT8_PTR(m,
466 APP_METADATA_OFFSET(32));
468 if (RTE_ETH_IS_IPV4_HDR(m->packet_type)) {
469 ip_hdr = (struct ipv4_hdr *)
470 &m_data[sizeof(struct ether_hdr)];
471 ip_dst = ip_hdr->dst_addr;
473 k32 = (uint32_t *) key;
474 k32[0] = ip_dst & 0xFFFFFF00;
475 } else if (RTE_ETH_IS_IPV6_HDR(m->packet_type)) {
476 ipv6_hdr = (struct ipv6_hdr *)
477 &m_data[sizeof(struct ether_hdr)];
478 ipv6_dst = ipv6_hdr->dst_addr;
480 memcpy(key, ipv6_dst, 16);
484 *signature = test_hash(key, 0, 0);
488 ret = rte_ring_sp_enqueue_bulk(
490 (void **) app.mbuf_rx.array,