[ceph.git] / ceph / src / spdk / dpdk / test / test / test_table.h

/* SPDX-License-Identifier: BSD-3-Clause
 * Copyright(c) 2010-2014 Intel Corporation
 */

#include <rte_table_stub.h>
#include <rte_table_lpm.h>
#include <rte_table_lpm_ipv6.h>
#include <rte_table_hash.h>
#include <rte_table_hash_cuckoo.h>
#include <rte_table_array.h>
#include <rte_pipeline.h>

#ifdef RTE_LIBRTE_ACL
#include <rte_table_acl.h>
#endif

#include <rte_port_ring.h>
#include <rte_port_ethdev.h>
#include <rte_port_source_sink.h>

#ifndef TEST_TABLE_H_
#define TEST_TABLE_H_

#define RING_SIZE 4096
#define MAX_BULK 32
#define N 65536
#define TIME_S 5
#define TEST_RING_FULL_EMTPY_ITER   8
#define N_PORTS             2
#define N_PKTS              2
#define N_PKTS_EXT          6
#define RING_RX rings_rx[0]
#define RING_RX_2 rings_rx[1]
#define RING_TX rings_tx[0]
#define RING_TX_2 rings_tx[1]
#define PORT_RX_RING_SIZE   128
#define PORT_TX_RING_SIZE   512
#define RING_RX_SIZE        128
#define RING_TX_SIZE        128
#define POOL_BUFFER_SIZE    RTE_MBUF_DEFAULT_BUF_SIZE
#define POOL_SIZE           (32 * 1024)
#define POOL_CACHE_SIZE     256
#define BURST_SIZE          8
#define WORKER_TYPE         1
#define MAX_DUMMY_PORTS     2
#define MP_NAME             "dummy_port_mempool"
#define MBUF_COUNT          (8000 * MAX_DUMMY_PORTS)
#define MP_CACHE_SZ         256
#define MP_SOCKET           0
#define MP_FLAGS            0

/* Macros */
#define APP_METADATA_OFFSET(offset) (sizeof(struct rte_mbuf) + (offset))

#define RING_ENQUEUE(ring, value) do {					\
	struct rte_mbuf *m;						\
	uint32_t *k32, *signature;					\
	uint8_t *key;							\
									\
	m = rte_pktmbuf_alloc(pool);					\
	if (m == NULL)							\
		return -1;						\
	signature = RTE_MBUF_METADATA_UINT32_PTR(m,			\
			APP_METADATA_OFFSET(0));		\
	key = RTE_MBUF_METADATA_UINT8_PTR(m,			\
			APP_METADATA_OFFSET(32));		\
	k32 = (uint32_t *) key;						\
	k32[0] = (value);						\
	*signature = pipeline_test_hash(key, NULL, 0, 0);		\
	rte_ring_enqueue((ring), m);					\
} while (0)

#define RUN_PIPELINE(pipeline) do {					\
	rte_pipeline_run((pipeline));					\
	rte_pipeline_flush((pipeline));					\
} while (0)

#define VERIFY(var, value) do {						\
	if ((var) != -(value))						\
		return var;						\
} while (0)

#define VERIFY_TRAFFIC(ring, sent, expected) do {			\
	unsigned i, n = 0;						\
	void *mbuf = NULL;						\
									\
	for (i = 0; i < (sent); i++) {					\
		if (!rte_ring_dequeue((ring), &mbuf)) {			\
			if (mbuf == NULL)				\
				continue;				\
			n++;						\
			rte_pktmbuf_free((struct rte_mbuf *)mbuf);	\
		}							\
		else							\
			break;						\
	}								\
	printf("Expected %d, got %d\n", expected, n);			\
	if (n != (expected)) {						\
		return -21;						\
	}								\
} while (0)

/* Function definitions */
uint64_t pipeline_test_hash(
	void *key,
	__attribute__((unused)) void *key_mask,
	__attribute__((unused)) uint32_t key_size,
	__attribute__((unused)) uint64_t seed);

uint32_t pipeline_test_hash_cuckoo(
	const void *key,
	__attribute__((unused)) uint32_t key_size,
	__attribute__((unused)) uint32_t seed);

/* Extern variables */
extern struct rte_pipeline *p;
extern struct rte_ring *rings_rx[N_PORTS];
extern struct rte_ring *rings_tx[N_PORTS];
extern struct rte_mempool *pool;
extern uint32_t port_in_id[N_PORTS];
extern uint32_t port_out_id[N_PORTS];
extern uint32_t port_out_id_type[3];
extern uint32_t table_id[N_PORTS*2];
extern uint64_t override_hit_mask;
extern uint64_t override_miss_mask;
extern uint64_t non_reserved_actions_hit;
extern uint64_t non_reserved_actions_miss;
extern uint8_t connect_miss_action_to_port_out;
extern uint8_t connect_miss_action_to_table;
extern uint32_t table_entry_default_action;
extern uint32_t table_entry_hit_action;
extern uint32_t table_entry_miss_action;
extern rte_pipeline_port_in_action_handler port_in_action;
extern rte_pipeline_port_out_action_handler port_out_action;
extern rte_pipeline_table_action_handler_hit action_handler_hit;
extern rte_pipeline_table_action_handler_miss action_handler_miss;

/* Global data types */
struct manage_ops {
	uint32_t op_id;
	void *op_data;
	int expected_result;
};

/* Internal pipeline structures */
struct rte_port_in {
	struct rte_port_in_ops ops;
	uint32_t burst_size;
	uint32_t table_id;
	void *h_port;
};

struct rte_port_out {
	struct rte_port_out_ops ops;
	void *h_port;
};

struct rte_table {
	struct rte_table_ops ops;
	rte_pipeline_table_action_handler_hit f_action;
	uint32_t table_next_id;
	uint32_t table_next_id_valid;
	uint8_t actions_lookup_miss[RTE_CACHE_LINE_SIZE];
	uint32_t action_data_size;
	void *h_table;
};

#define RTE_PIPELINE_MAX_NAME_SZ                           124

struct rte_pipeline {
	char name[RTE_PIPELINE_MAX_NAME_SZ];
	uint32_t socket_id;
	struct rte_port_in ports_in[16];
	struct rte_port_out ports_out[16];
	struct rte_table tables[64];
	uint32_t num_ports_in;
	uint32_t num_ports_out;
	uint32_t num_tables;
	struct rte_mbuf *pkts[RTE_PORT_IN_BURST_SIZE_MAX];
	struct rte_table_entry *actions[RTE_PORT_IN_BURST_SIZE_MAX];
	uint64_t mask_action[64];
	uint32_t mask_actions;
};
#endif
Commit	Line	Data
11fdf7f2 TL	1	/* SPDX-License-Identifier: BSD-3-Clause
11fdf7f2 TL	2	* Copyright(c) 2010-2014 Intel Corporation
7c673cae FG	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>
11fdf7f2	9	#include <rte_table_hash_cuckoo.h>
7c673cae FG	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); \
11fdf7f2	69	*signature = pipeline_test_hash(key, NULL, 0, 0); \
7c673cae FG	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,
11fdf7f2	106	__attribute__((unused)) void *key_mask,
7c673cae FG	107	__attribute__((unused)) uint32_t key_size,
	108	__attribute__((unused)) uint64_t seed);
	109
11fdf7f2 TL	110	uint32_t pipeline_test_hash_cuckoo(
	111	const void *key,
	112	__attribute__((unused)) uint32_t key_size,
	113	__attribute__((unused)) uint32_t seed);
	114
7c673cae FG	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