app/test/test_table.h

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2010-2014 Intel Corporation
   3  */
   4
   5 #include <rte_table_stub.h>
   6 #include <rte_table_lpm.h>
   7 #include <rte_table_lpm_ipv6.h>
   8 #include <rte_table_hash.h>
   9 #include <rte_table_hash_cuckoo.h>
  10 #include <rte_table_array.h>
  11 #include <rte_pipeline.h>
  12
  13 #ifdef RTE_LIBRTE_ACL
  14 #include <rte_table_acl.h>
  15 #endif
  16
  17 #include <rte_port_ring.h>
  18 #include <rte_port_ethdev.h>
  19 #include <rte_port_source_sink.h>
  20
  21 #ifndef TEST_TABLE_H_
  22 #define TEST_TABLE_H_
  23
  24 #define RING_SIZE 4096
  25 #define MAX_BULK 32
  26 #define N 65536
  27 #define TIME_S 5
  28 #define TEST_RING_FULL_EMTPY_ITER   8
  29 #define N_PORTS             2
  30 #define N_PKTS              2
  31 #define N_PKTS_EXT          6
  32 #define RING_RX rings_rx[0]
  33 #define RING_RX_2 rings_rx[1]
  34 #define RING_TX rings_tx[0]
  35 #define RING_TX_2 rings_tx[1]
  36 #define PORT_RX_RING_SIZE   128
  37 #define PORT_TX_RING_SIZE   512
  38 #define RING_RX_SIZE        128
  39 #define RING_TX_SIZE        128
  40 #define POOL_BUFFER_SIZE    RTE_MBUF_DEFAULT_BUF_SIZE
  41 #define POOL_SIZE           (32 * 1024)
  42 #define POOL_CACHE_SIZE     256
  43 #define BURST_SIZE          8
  44 #define WORKER_TYPE         1
  45 #define MAX_DUMMY_PORTS     2
  46 #define MP_NAME             "dummy_port_mempool"
  47 #define MBUF_COUNT          (8000 * MAX_DUMMY_PORTS)
  48 #define MP_CACHE_SZ         256
  49 #define MP_SOCKET           0
  50 #define MP_FLAGS            0
  51
  52 /* Macros */
  53 #define APP_METADATA_OFFSET(offset) (sizeof(struct rte_mbuf) + (offset))
  54
  55 #define RING_ENQUEUE(ring, value) do {                                  \
  56         struct rte_mbuf *m;                                             \
  57         uint32_t *k32, *signature;                                      \
  58         uint8_t *key;                                                   \
  59                                                                         \
  60         m = rte_pktmbuf_alloc(pool);                                    \
  61         if (m == NULL)                                                  \
  62                 return -1;                                              \
  63         signature = RTE_MBUF_METADATA_UINT32_PTR(m,                     \
  64                         APP_METADATA_OFFSET(0));                \
  65         key = RTE_MBUF_METADATA_UINT8_PTR(m,                    \
  66                         APP_METADATA_OFFSET(32));               \
  67         k32 = (uint32_t *) key;                                         \
  68         k32[0] = (value);                                               \
  69         *signature = pipeline_test_hash(key, NULL, 0, 0);               \
  70         rte_ring_enqueue((ring), m);                                    \
  71 } while (0)
  72
  73 #define RUN_PIPELINE(pipeline) do {                                     \
  74         rte_pipeline_run((pipeline));                                   \
  75         rte_pipeline_flush((pipeline));                                 \
  76 } while (0)
  77
  78 #define VERIFY(var, value) do {                                         \
  79         if ((var) != -(value))                                          \
  80                 return var;                                             \
  81 } while (0)
  82
  83 #define VERIFY_TRAFFIC(ring, sent, expected) do {                       \
  84         unsigned i, n = 0;                                              \
  85         void *mbuf = NULL;                                              \
  86                                                                         \
  87         for (i = 0; i < (sent); i++) {                                  \
  88                 if (!rte_ring_dequeue((ring), &mbuf)) {                 \
  89                         if (mbuf == NULL)                               \
  90                                 continue;                               \
  91                         n++;                                            \
  92                         rte_pktmbuf_free((struct rte_mbuf *)mbuf);      \
  93                 }                                                       \
  94                 else                                                    \
  95                         break;                                          \
  96         }                                                               \
  97         printf("Expected %d, got %d\n", expected, n);                   \
  98         if (n != (expected)) {                                          \
  99                 return -21;                                             \
 100         }                                                               \
 101 } while (0)
 102
 103 /* Function definitions */
 104 uint64_t pipeline_test_hash(
 105         void *key,
 106         __rte_unused void *key_mask,
 107         __rte_unused uint32_t key_size,
 108         __rte_unused uint64_t seed);
 109
 110 uint32_t pipeline_test_hash_cuckoo(
 111         const void *key,
 112         __rte_unused uint32_t key_size,
 113         __rte_unused uint32_t seed);
 114
 115 /* Extern variables */
 116 extern struct rte_pipeline *p;
 117 extern struct rte_ring *rings_rx[N_PORTS];
 118 extern struct rte_ring *rings_tx[N_PORTS];
 119 extern struct rte_mempool *pool;
 120 extern uint32_t port_in_id[N_PORTS];
 121 extern uint32_t port_out_id[N_PORTS];
 122 extern uint32_t port_out_id_type[3];
 123 extern uint32_t table_id[N_PORTS*2];
 124 extern uint64_t override_hit_mask;
 125 extern uint64_t override_miss_mask;
 126 extern uint64_t non_reserved_actions_hit;
 127 extern uint64_t non_reserved_actions_miss;
 128 extern uint8_t connect_miss_action_to_port_out;
 129 extern uint8_t connect_miss_action_to_table;
 130 extern uint32_t table_entry_default_action;
 131 extern uint32_t table_entry_hit_action;
 132 extern uint32_t table_entry_miss_action;
 133 extern rte_pipeline_port_in_action_handler port_in_action;
 134 extern rte_pipeline_port_out_action_handler port_out_action;
 135 extern rte_pipeline_table_action_handler_hit action_handler_hit;
 136 extern rte_pipeline_table_action_handler_miss action_handler_miss;
 137
 138 /* Global data types */
 139 struct manage_ops {
 140         uint32_t op_id;
 141         void *op_data;
 142         int expected_result;
 143 };
 144
 145 /* Internal pipeline structures */
 146 struct rte_port_in {
 147         struct rte_port_in_ops ops;
 148         uint32_t burst_size;
 149         uint32_t table_id;
 150         void *h_port;
 151 };
 152
 153 struct rte_port_out {
 154         struct rte_port_out_ops ops;
 155         void *h_port;
 156 };
 157
 158 struct rte_table {
 159         struct rte_table_ops ops;
 160         rte_pipeline_table_action_handler_hit f_action;
 161         uint32_t table_next_id;
 162         uint32_t table_next_id_valid;
 163         uint8_t actions_lookup_miss[RTE_CACHE_LINE_SIZE];
 164         uint32_t action_data_size;
 165         void *h_table;
 166 };
 167
 168 #define RTE_PIPELINE_MAX_NAME_SZ                           124
 169
 170 struct rte_pipeline {
 171         char name[RTE_PIPELINE_MAX_NAME_SZ];
 172         uint32_t socket_id;
 173         struct rte_port_in ports_in[16];
 174         struct rte_port_out ports_out[16];
 175         struct rte_table tables[64];
 176         uint32_t num_ports_in;
 177         uint32_t num_ports_out;
 178         uint32_t num_tables;
 179         struct rte_mbuf *pkts[RTE_PORT_IN_BURST_SIZE_MAX];
 180         struct rte_table_entry *actions[RTE_PORT_IN_BURST_SIZE_MAX];
 181         uint64_t mask_action[64];
 182         uint32_t mask_actions;
 183 };
 184 #endif