1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2010-2014 Intel Corporation
5 #include <rte_string_fns.h>
10 #include <rte_cycles.h>
11 #include <rte_per_lcore.h>
12 #include <rte_lcore.h>
15 #define PRINT_USAGE_START "%s [EAL options] --\n"
17 #define RTE_LOGTYPE_TESTACL RTE_LOGTYPE_USER1
19 #define APP_NAME "TESTACL"
21 #define GET_CB_FIELD(in, fd, base, lim, dlm) do { \
25 val = strtoul((in), &end_fld, (base)); \
26 if (errno != 0 || end_fld[0] != (dlm) || val > (lim)) \
28 (fd) = (typeof(fd))val; \
32 #define OPT_RULE_FILE "rulesf"
33 #define OPT_TRACE_FILE "tracef"
34 #define OPT_RULE_NUM "rulenum"
35 #define OPT_TRACE_NUM "tracenum"
36 #define OPT_TRACE_STEP "tracestep"
37 #define OPT_SEARCH_ALG "alg"
38 #define OPT_BLD_CATEGORIES "bldcat"
39 #define OPT_RUN_CATEGORIES "runcat"
40 #define OPT_MAX_SIZE "maxsize"
41 #define OPT_ITER_NUM "iter"
42 #define OPT_VERBOSE "verbose"
43 #define OPT_IPV6 "ipv6"
45 #define TRACE_DEFAULT_NUM 0x10000
46 #define TRACE_STEP_MAX 0x1000
47 #define TRACE_STEP_DEF 0x100
49 #define RULE_NUM 0x10000
60 enum rte_acl_classify_alg alg;
63 static const struct acl_alg acl_alg[] = {
66 .alg = RTE_ACL_CLASSIFY_SCALAR,
70 .alg = RTE_ACL_CLASSIFY_SSE,
74 .alg = RTE_ACL_CLASSIFY_AVX2,
78 .alg = RTE_ACL_CLASSIFY_NEON,
82 .alg = RTE_ACL_CLASSIFY_ALTIVEC,
86 .alg = RTE_ACL_CLASSIFY_AVX512X16,
90 .alg = RTE_ACL_CLASSIFY_AVX512X32,
96 const char *rule_file;
97 const char *trace_file;
99 uint32_t bld_categories;
100 uint32_t run_categories;
109 uint32_t used_traces;
111 struct rte_acl_ctx *acx;
115 .nb_rules = RULE_NUM,
116 .nb_traces = TRACE_DEFAULT_NUM,
117 .trace_step = TRACE_STEP_DEF,
122 .alg = RTE_ACL_CLASSIFY_DEFAULT,
127 static struct rte_acl_param prm = {
129 .socket_id = SOCKET_ID_ANY,
133 * Rule and trace formats definitions.
154 * That effectively defines order of IPV4VLAN classifications:
156 * - VLAN (TAG and DOMAIN)
159 * - PORTS (SRC and DST)
162 RTE_ACL_IPV4VLAN_PROTO,
163 RTE_ACL_IPV4VLAN_VLAN,
164 RTE_ACL_IPV4VLAN_SRC,
165 RTE_ACL_IPV4VLAN_DST,
166 RTE_ACL_IPV4VLAN_PORTS,
170 struct rte_acl_field_def ipv4_defs[NUM_FIELDS_IPV4] = {
172 .type = RTE_ACL_FIELD_TYPE_BITMASK,
173 .size = sizeof(uint8_t),
174 .field_index = PROTO_FIELD_IPV4,
175 .input_index = RTE_ACL_IPV4VLAN_PROTO,
176 .offset = offsetof(struct ipv4_5tuple, proto),
179 .type = RTE_ACL_FIELD_TYPE_MASK,
180 .size = sizeof(uint32_t),
181 .field_index = SRC_FIELD_IPV4,
182 .input_index = RTE_ACL_IPV4VLAN_SRC,
183 .offset = offsetof(struct ipv4_5tuple, ip_src),
186 .type = RTE_ACL_FIELD_TYPE_MASK,
187 .size = sizeof(uint32_t),
188 .field_index = DST_FIELD_IPV4,
189 .input_index = RTE_ACL_IPV4VLAN_DST,
190 .offset = offsetof(struct ipv4_5tuple, ip_dst),
193 .type = RTE_ACL_FIELD_TYPE_RANGE,
194 .size = sizeof(uint16_t),
195 .field_index = SRCP_FIELD_IPV4,
196 .input_index = RTE_ACL_IPV4VLAN_PORTS,
197 .offset = offsetof(struct ipv4_5tuple, port_src),
200 .type = RTE_ACL_FIELD_TYPE_RANGE,
201 .size = sizeof(uint16_t),
202 .field_index = DSTP_FIELD_IPV4,
203 .input_index = RTE_ACL_IPV4VLAN_PORTS,
204 .offset = offsetof(struct ipv4_5tuple, port_dst),
208 #define IPV6_ADDR_LEN 16
209 #define IPV6_ADDR_U16 (IPV6_ADDR_LEN / sizeof(uint16_t))
210 #define IPV6_ADDR_U32 (IPV6_ADDR_LEN / sizeof(uint32_t))
214 uint32_t ip_src[IPV6_ADDR_U32];
215 uint32_t ip_dst[IPV6_ADDR_U32];
235 struct rte_acl_field_def ipv6_defs[NUM_FIELDS_IPV6] = {
237 .type = RTE_ACL_FIELD_TYPE_BITMASK,
238 .size = sizeof(uint8_t),
239 .field_index = PROTO_FIELD_IPV6,
240 .input_index = PROTO_FIELD_IPV6,
241 .offset = offsetof(struct ipv6_5tuple, proto),
244 .type = RTE_ACL_FIELD_TYPE_MASK,
245 .size = sizeof(uint32_t),
246 .field_index = SRC1_FIELD_IPV6,
247 .input_index = SRC1_FIELD_IPV6,
248 .offset = offsetof(struct ipv6_5tuple, ip_src[0]),
251 .type = RTE_ACL_FIELD_TYPE_MASK,
252 .size = sizeof(uint32_t),
253 .field_index = SRC2_FIELD_IPV6,
254 .input_index = SRC2_FIELD_IPV6,
255 .offset = offsetof(struct ipv6_5tuple, ip_src[1]),
258 .type = RTE_ACL_FIELD_TYPE_MASK,
259 .size = sizeof(uint32_t),
260 .field_index = SRC3_FIELD_IPV6,
261 .input_index = SRC3_FIELD_IPV6,
262 .offset = offsetof(struct ipv6_5tuple, ip_src[2]),
265 .type = RTE_ACL_FIELD_TYPE_MASK,
266 .size = sizeof(uint32_t),
267 .field_index = SRC4_FIELD_IPV6,
268 .input_index = SRC4_FIELD_IPV6,
269 .offset = offsetof(struct ipv6_5tuple, ip_src[3]),
272 .type = RTE_ACL_FIELD_TYPE_MASK,
273 .size = sizeof(uint32_t),
274 .field_index = DST1_FIELD_IPV6,
275 .input_index = DST1_FIELD_IPV6,
276 .offset = offsetof(struct ipv6_5tuple, ip_dst[0]),
279 .type = RTE_ACL_FIELD_TYPE_MASK,
280 .size = sizeof(uint32_t),
281 .field_index = DST2_FIELD_IPV6,
282 .input_index = DST2_FIELD_IPV6,
283 .offset = offsetof(struct ipv6_5tuple, ip_dst[1]),
286 .type = RTE_ACL_FIELD_TYPE_MASK,
287 .size = sizeof(uint32_t),
288 .field_index = DST3_FIELD_IPV6,
289 .input_index = DST3_FIELD_IPV6,
290 .offset = offsetof(struct ipv6_5tuple, ip_dst[2]),
293 .type = RTE_ACL_FIELD_TYPE_MASK,
294 .size = sizeof(uint32_t),
295 .field_index = DST4_FIELD_IPV6,
296 .input_index = DST4_FIELD_IPV6,
297 .offset = offsetof(struct ipv6_5tuple, ip_dst[3]),
300 .type = RTE_ACL_FIELD_TYPE_RANGE,
301 .size = sizeof(uint16_t),
302 .field_index = SRCP_FIELD_IPV6,
303 .input_index = SRCP_FIELD_IPV6,
304 .offset = offsetof(struct ipv6_5tuple, port_src),
307 .type = RTE_ACL_FIELD_TYPE_RANGE,
308 .size = sizeof(uint16_t),
309 .field_index = DSTP_FIELD_IPV6,
310 .input_index = SRCP_FIELD_IPV6,
311 .offset = offsetof(struct ipv6_5tuple, port_dst),
321 CB_FLD_SRC_PORT_HIGH,
324 CB_FLD_DST_PORT_HIGH,
338 RTE_ACL_RULE_DEF(acl_rule, RTE_ACL_MAX_FIELDS);
340 static const char cb_port_delim[] = ":";
342 static char line[LINE_MAX];
344 #define dump_verbose(lvl, fh, fmt, args...) do { \
345 if ((lvl) <= (int32_t)config.verbose) \
346 fprintf(fh, fmt, ##args); \
351 * Parse ClassBench input trace (test vectors and expected results) file.
353 * <src_ipv4_addr> <space> <dst_ipv4_addr> <space> \
354 * <src_port> <space> <dst_port> <space> <proto>
357 parse_cb_ipv4_trace(char *str, struct ipv4_5tuple *v)
360 char *s, *sp, *in[CB_TRC_NUM];
361 static const char *dlm = " \t\n";
364 for (i = 0; i != RTE_DIM(in); i++) {
365 in[i] = strtok_r(s, dlm, &sp);
371 GET_CB_FIELD(in[CB_TRC_SRC_ADDR], v->ip_src, 0, UINT32_MAX, 0);
372 GET_CB_FIELD(in[CB_TRC_DST_ADDR], v->ip_dst, 0, UINT32_MAX, 0);
373 GET_CB_FIELD(in[CB_TRC_SRC_PORT], v->port_src, 0, UINT16_MAX, 0);
374 GET_CB_FIELD(in[CB_TRC_DST_PORT], v->port_dst, 0, UINT16_MAX, 0);
375 GET_CB_FIELD(in[CB_TRC_PROTO], v->proto, 0, UINT8_MAX, 0);
377 /* convert to network byte order. */
378 v->ip_src = rte_cpu_to_be_32(v->ip_src);
379 v->ip_dst = rte_cpu_to_be_32(v->ip_dst);
380 v->port_src = rte_cpu_to_be_16(v->port_src);
381 v->port_dst = rte_cpu_to_be_16(v->port_dst);
387 * Parses IPV6 address, exepcts the following format:
388 * XXXX:XXXX:XXXX:XXXX:XXXX:XXXX:XXXX:XXXX (where X - is a hexedecimal digit).
391 parse_ipv6_addr(const char *in, const char **end, uint32_t v[IPV6_ADDR_U32],
394 uint32_t addr[IPV6_ADDR_U16];
396 GET_CB_FIELD(in, addr[0], 16, UINT16_MAX, ':');
397 GET_CB_FIELD(in, addr[1], 16, UINT16_MAX, ':');
398 GET_CB_FIELD(in, addr[2], 16, UINT16_MAX, ':');
399 GET_CB_FIELD(in, addr[3], 16, UINT16_MAX, ':');
400 GET_CB_FIELD(in, addr[4], 16, UINT16_MAX, ':');
401 GET_CB_FIELD(in, addr[5], 16, UINT16_MAX, ':');
402 GET_CB_FIELD(in, addr[6], 16, UINT16_MAX, ':');
403 GET_CB_FIELD(in, addr[7], 16, UINT16_MAX, dlm);
407 v[0] = (addr[0] << 16) + addr[1];
408 v[1] = (addr[2] << 16) + addr[3];
409 v[2] = (addr[4] << 16) + addr[5];
410 v[3] = (addr[6] << 16) + addr[7];
416 parse_cb_ipv6_addr_trace(const char *in, uint32_t v[IPV6_ADDR_U32])
421 rc = parse_ipv6_addr(in, &end, v, 0);
425 v[0] = rte_cpu_to_be_32(v[0]);
426 v[1] = rte_cpu_to_be_32(v[1]);
427 v[2] = rte_cpu_to_be_32(v[2]);
428 v[3] = rte_cpu_to_be_32(v[3]);
434 * Parse ClassBench input trace (test vectors and expected results) file.
436 * <src_ipv6_addr> <space> <dst_ipv6_addr> <space> \
437 * <src_port> <space> <dst_port> <space> <proto>
440 parse_cb_ipv6_trace(char *str, struct ipv6_5tuple *v)
443 char *s, *sp, *in[CB_TRC_NUM];
444 static const char *dlm = " \t\n";
447 for (i = 0; i != RTE_DIM(in); i++) {
448 in[i] = strtok_r(s, dlm, &sp);
454 /* get ip6 src address. */
455 rc = parse_cb_ipv6_addr_trace(in[CB_TRC_SRC_ADDR], v->ip_src);
459 /* get ip6 dst address. */
460 rc = parse_cb_ipv6_addr_trace(in[CB_TRC_DST_ADDR], v->ip_dst);
464 GET_CB_FIELD(in[CB_TRC_SRC_PORT], v->port_src, 0, UINT16_MAX, 0);
465 GET_CB_FIELD(in[CB_TRC_DST_PORT], v->port_dst, 0, UINT16_MAX, 0);
466 GET_CB_FIELD(in[CB_TRC_PROTO], v->proto, 0, UINT8_MAX, 0);
468 /* convert to network byte order. */
469 v->port_src = rte_cpu_to_be_16(v->port_src);
470 v->port_dst = rte_cpu_to_be_16(v->port_dst);
478 static const char name[] = APP_NAME;
482 struct ipv4_5tuple *v;
483 struct ipv6_5tuple *w;
485 sz = config.nb_traces * (config.ipv6 ? sizeof(*w) : sizeof(*v));
486 config.traces = rte_zmalloc_socket(name, sz, RTE_CACHE_LINE_SIZE,
488 if (config.traces == NULL)
489 rte_exit(EXIT_FAILURE, "Cannot allocate %zu bytes for "
490 "requested %u number of trace records\n",
491 sz, config.nb_traces);
493 f = fopen(config.trace_file, "r");
495 rte_exit(-EINVAL, "failed to open file: %s\n",
500 for (n = 0; n != config.nb_traces; n++) {
502 if (fgets(line, sizeof(line), f) == NULL)
506 if (parse_cb_ipv6_trace(line, w + n) != 0)
507 rte_exit(EXIT_FAILURE,
508 "%s: failed to parse ipv6 trace "
509 "record at line %u\n",
510 config.trace_file, n + 1);
512 if (parse_cb_ipv4_trace(line, v + n) != 0)
513 rte_exit(EXIT_FAILURE,
514 "%s: failed to parse ipv4 trace "
515 "record at line %u\n",
516 config.trace_file, n + 1);
520 config.used_traces = n;
525 parse_ipv6_net(const char *in, struct rte_acl_field field[4])
530 const uint32_t nbu32 = sizeof(uint32_t) * CHAR_BIT;
533 rc = parse_ipv6_addr(in, &mp, v, '/');
538 GET_CB_FIELD(mp, m, 0, CHAR_BIT * sizeof(v), 0);
540 /* put all together. */
541 for (i = 0; i != RTE_DIM(v); i++) {
542 if (m >= (i + 1) * nbu32)
543 field[i].mask_range.u32 = nbu32;
545 field[i].mask_range.u32 = m > (i * nbu32) ?
548 field[i].value.u32 = v[i];
556 parse_cb_ipv6_rule(char *str, struct acl_rule *v)
559 char *s, *sp, *in[CB_FLD_NUM];
560 static const char *dlm = " \t\n";
565 if (strchr(str, '@') != str)
570 for (i = 0; i != RTE_DIM(in); i++) {
571 in[i] = strtok_r(s, dlm, &sp);
577 rc = parse_ipv6_net(in[CB_FLD_SRC_ADDR], v->field + SRC1_FIELD_IPV6);
579 RTE_LOG(ERR, TESTACL,
580 "failed to read source address/mask: %s\n",
581 in[CB_FLD_SRC_ADDR]);
585 rc = parse_ipv6_net(in[CB_FLD_DST_ADDR], v->field + DST1_FIELD_IPV6);
587 RTE_LOG(ERR, TESTACL,
588 "failed to read destination address/mask: %s\n",
589 in[CB_FLD_DST_ADDR]);
594 GET_CB_FIELD(in[CB_FLD_SRC_PORT_LOW],
595 v->field[SRCP_FIELD_IPV6].value.u16,
597 GET_CB_FIELD(in[CB_FLD_SRC_PORT_HIGH],
598 v->field[SRCP_FIELD_IPV6].mask_range.u16,
601 if (strncmp(in[CB_FLD_SRC_PORT_DLM], cb_port_delim,
602 sizeof(cb_port_delim)) != 0)
605 /* destination port. */
606 GET_CB_FIELD(in[CB_FLD_DST_PORT_LOW],
607 v->field[DSTP_FIELD_IPV6].value.u16,
609 GET_CB_FIELD(in[CB_FLD_DST_PORT_HIGH],
610 v->field[DSTP_FIELD_IPV6].mask_range.u16,
613 if (strncmp(in[CB_FLD_DST_PORT_DLM], cb_port_delim,
614 sizeof(cb_port_delim)) != 0)
617 GET_CB_FIELD(in[CB_FLD_PROTO], v->field[PROTO_FIELD_IPV6].value.u8,
619 GET_CB_FIELD(in[CB_FLD_PROTO], v->field[PROTO_FIELD_IPV6].mask_range.u8,
626 parse_ipv4_net(const char *in, uint32_t *addr, uint32_t *mask_len)
628 uint8_t a, b, c, d, m;
630 GET_CB_FIELD(in, a, 0, UINT8_MAX, '.');
631 GET_CB_FIELD(in, b, 0, UINT8_MAX, '.');
632 GET_CB_FIELD(in, c, 0, UINT8_MAX, '.');
633 GET_CB_FIELD(in, d, 0, UINT8_MAX, '/');
634 GET_CB_FIELD(in, m, 0, sizeof(uint32_t) * CHAR_BIT, 0);
636 addr[0] = RTE_IPV4(a, b, c, d);
642 * Parse ClassBench rules file.
644 * '@'<src_ipv4_addr>'/'<masklen> <space> \
645 * <dst_ipv4_addr>'/'<masklen> <space> \
646 * <src_port_low> <space> ":" <src_port_high> <space> \
647 * <dst_port_low> <space> ":" <dst_port_high> <space> \
651 parse_cb_ipv4_rule(char *str, struct acl_rule *v)
654 char *s, *sp, *in[CB_FLD_NUM];
655 static const char *dlm = " \t\n";
660 if (strchr(str, '@') != str)
665 for (i = 0; i != RTE_DIM(in); i++) {
666 in[i] = strtok_r(s, dlm, &sp);
672 rc = parse_ipv4_net(in[CB_FLD_SRC_ADDR],
673 &v->field[SRC_FIELD_IPV4].value.u32,
674 &v->field[SRC_FIELD_IPV4].mask_range.u32);
676 RTE_LOG(ERR, TESTACL,
677 "failed to read source address/mask: %s\n",
678 in[CB_FLD_SRC_ADDR]);
682 rc = parse_ipv4_net(in[CB_FLD_DST_ADDR],
683 &v->field[DST_FIELD_IPV4].value.u32,
684 &v->field[DST_FIELD_IPV4].mask_range.u32);
686 RTE_LOG(ERR, TESTACL,
687 "failed to read destination address/mask: %s\n",
688 in[CB_FLD_DST_ADDR]);
693 GET_CB_FIELD(in[CB_FLD_SRC_PORT_LOW],
694 v->field[SRCP_FIELD_IPV4].value.u16,
696 GET_CB_FIELD(in[CB_FLD_SRC_PORT_HIGH],
697 v->field[SRCP_FIELD_IPV4].mask_range.u16,
700 if (strncmp(in[CB_FLD_SRC_PORT_DLM], cb_port_delim,
701 sizeof(cb_port_delim)) != 0)
704 /* destination port. */
705 GET_CB_FIELD(in[CB_FLD_DST_PORT_LOW],
706 v->field[DSTP_FIELD_IPV4].value.u16,
708 GET_CB_FIELD(in[CB_FLD_DST_PORT_HIGH],
709 v->field[DSTP_FIELD_IPV4].mask_range.u16,
712 if (strncmp(in[CB_FLD_DST_PORT_DLM], cb_port_delim,
713 sizeof(cb_port_delim)) != 0)
716 GET_CB_FIELD(in[CB_FLD_PROTO], v->field[PROTO_FIELD_IPV4].value.u8,
718 GET_CB_FIELD(in[CB_FLD_PROTO], v->field[PROTO_FIELD_IPV4].mask_range.u8,
724 typedef int (*parse_5tuple)(char *text, struct acl_rule *rule);
727 add_cb_rules(FILE *f, struct rte_acl_ctx *ctx)
734 memset(&v, 0, sizeof(v));
735 parser = (config.ipv6 != 0) ? parse_cb_ipv6_rule : parse_cb_ipv4_rule;
737 for (n = 1; fgets(line, sizeof(line), f) != NULL; n++) {
739 rc = parser(line, &v);
741 RTE_LOG(ERR, TESTACL, "line %u: parse_cb_ipv4vlan_rule"
742 " failed, error code: %d (%s)\n",
743 n, rc, strerror(-rc));
747 v.data.category_mask = RTE_LEN2MASK(RTE_ACL_MAX_CATEGORIES,
748 typeof(v.data.category_mask));
749 v.data.priority = RTE_ACL_MAX_PRIORITY - n;
752 rc = rte_acl_add_rules(ctx, (struct rte_acl_rule *)&v, 1);
754 RTE_LOG(ERR, TESTACL, "line %u: failed to add rules "
755 "into ACL context, error code: %d (%s)\n",
756 n, rc, strerror(-rc));
769 struct rte_acl_config cfg;
771 memset(&cfg, 0, sizeof(cfg));
773 /* setup ACL build config. */
775 cfg.num_fields = RTE_DIM(ipv6_defs);
776 memcpy(&cfg.defs, ipv6_defs, sizeof(ipv6_defs));
778 cfg.num_fields = RTE_DIM(ipv4_defs);
779 memcpy(&cfg.defs, ipv4_defs, sizeof(ipv4_defs));
781 cfg.num_categories = config.bld_categories;
782 cfg.max_size = config.max_size;
784 /* setup ACL creation parameters. */
785 prm.rule_size = RTE_ACL_RULE_SZ(cfg.num_fields);
786 prm.max_rule_num = config.nb_rules;
788 config.acx = rte_acl_create(&prm);
789 if (config.acx == NULL)
790 rte_exit(rte_errno, "failed to create ACL context\n");
792 /* set default classify method for this context. */
793 if (config.alg.alg != RTE_ACL_CLASSIFY_DEFAULT) {
794 ret = rte_acl_set_ctx_classify(config.acx, config.alg.alg);
796 rte_exit(ret, "failed to setup %s method "
797 "for ACL context\n", config.alg.name);
801 f = fopen(config.rule_file, "r");
803 rte_exit(-EINVAL, "failed to open file %s\n",
806 ret = add_cb_rules(f, config.acx);
808 rte_exit(ret, "failed to add rules into ACL context\n");
813 ret = rte_acl_build(config.acx, &cfg);
815 dump_verbose(DUMP_NONE, stdout,
816 "rte_acl_build(%u) finished with %d\n",
817 config.bld_categories, ret);
819 rte_acl_dump(config.acx);
822 rte_exit(ret, "failed to build search context\n");
826 search_ip5tuples_once(uint32_t categories, uint32_t step, const char *alg)
829 uint32_t i, j, k, n, r;
830 const uint8_t *data[step], *v;
831 uint32_t results[step * categories];
834 for (i = 0; i != config.used_traces; i += n) {
836 n = RTE_MIN(step, config.used_traces - i);
838 for (j = 0; j != n; j++) {
840 v += config.trace_sz;
843 ret = rte_acl_classify(config.acx, data, results,
847 rte_exit(ret, "classify for ipv%c_5tuples returns %d\n",
848 config.ipv6 ? '6' : '4', ret);
850 for (r = 0, j = 0; j != n; j++) {
851 for (k = 0; k != categories; k++, r++) {
852 dump_verbose(DUMP_PKT, stdout,
853 "ipv%c_5tuple: %u, category: %u, "
855 config.ipv6 ? '6' : '4',
856 i + j + 1, k, results[r] - 1);
862 dump_verbose(DUMP_SEARCH, stdout,
863 "%s(%u, %u, %s) returns %u\n", __func__,
864 categories, step, alg, i);
869 search_ip5tuples(__rte_unused void *arg)
871 uint64_t pkt, start, tm;
875 lcore = rte_lcore_id();
876 start = rte_rdtsc_precise();
879 for (i = 0; i != config.iter_num; i++) {
880 pkt += search_ip5tuples_once(config.run_categories,
881 config.trace_step, config.alg.name);
884 tm = rte_rdtsc_precise() - start;
886 st = (long double)tm / rte_get_timer_hz();
887 dump_verbose(DUMP_NONE, stdout,
888 "%s @lcore %u: %" PRIu32 " iterations, %" PRIu64 " pkts, %"
889 PRIu32 " categories, %" PRIu64 " cycles (%.2Lf sec), "
890 "%.2Lf cycles/pkt, %.2Lf pkt/sec\n",
891 __func__, lcore, i, pkt,
892 config.run_categories, tm, st,
893 (pkt == 0) ? 0 : (long double)tm / pkt, pkt / st);
899 get_ulong_opt(const char *opt, const char *name, size_t min, size_t max)
905 val = strtoul(opt, &end, 0);
906 if (errno != 0 || end[0] != 0 || val > max || val < min)
907 rte_exit(-EINVAL, "invalid value: \"%s\" for option: %s\n",
913 get_alg_opt(const char *opt, const char *name)
917 for (i = 0; i != RTE_DIM(acl_alg); i++) {
918 if (strcmp(opt, acl_alg[i].name) == 0) {
919 config.alg = acl_alg[i];
924 rte_exit(-EINVAL, "invalid value: \"%s\" for option: %s\n",
929 print_usage(const char *prgname)
937 for (i = 0; i < RTE_DIM(acl_alg) - 1; i++) {
938 rc = snprintf(buf + n, sizeof(buf) - n, "%s|",
940 if (rc > sizeof(buf) - n)
945 strlcpy(buf + n, acl_alg[i].name, sizeof(buf) - n);
949 "--" OPT_RULE_FILE "=<rules set file>\n"
950 "[--" OPT_TRACE_FILE "=<input traces file>]\n"
952 "=<maximum number of rules for ACL context>]\n"
954 "=<number of traces to read binary file in>]\n"
956 "=<number of traces to classify per one call>]\n"
957 "[--" OPT_BLD_CATEGORIES
958 "=<number of categories to build with>]\n"
959 "[--" OPT_RUN_CATEGORIES
960 "=<number of categories to run with> "
961 "should be either 1 or multiple of %zu, "
962 "but not greater then %u]\n"
964 "=<size limit (in bytes) for runtime ACL strucutures> "
965 "leave 0 for default behaviour]\n"
966 "[--" OPT_ITER_NUM "=<number of iterations to perform>]\n"
967 "[--" OPT_VERBOSE "=<verbose level>]\n"
968 "[--" OPT_SEARCH_ALG "=%s]\n"
969 "[--" OPT_IPV6 "=<IPv6 rules and trace files>]\n",
970 prgname, RTE_ACL_RESULTS_MULTIPLIER,
971 (uint32_t)RTE_ACL_MAX_CATEGORIES,
978 fprintf(f, "%s:\n", __func__);
979 fprintf(f, "%s:%s\n", OPT_RULE_FILE, config.rule_file);
980 fprintf(f, "%s:%s\n", OPT_TRACE_FILE, config.trace_file);
981 fprintf(f, "%s:%u\n", OPT_RULE_NUM, config.nb_rules);
982 fprintf(f, "%s:%u\n", OPT_TRACE_NUM, config.nb_traces);
983 fprintf(f, "%s:%u\n", OPT_TRACE_STEP, config.trace_step);
984 fprintf(f, "%s:%u\n", OPT_BLD_CATEGORIES, config.bld_categories);
985 fprintf(f, "%s:%u\n", OPT_RUN_CATEGORIES, config.run_categories);
986 fprintf(f, "%s:%zu\n", OPT_MAX_SIZE, config.max_size);
987 fprintf(f, "%s:%u\n", OPT_ITER_NUM, config.iter_num);
988 fprintf(f, "%s:%u\n", OPT_VERBOSE, config.verbose);
989 fprintf(f, "%s:%u(%s)\n", OPT_SEARCH_ALG, config.alg.alg,
991 fprintf(f, "%s:%u\n", OPT_IPV6, config.ipv6);
997 if (config.rule_file == NULL) {
998 print_usage(config.prgname);
999 rte_exit(-EINVAL, "mandatory option %s is not specified\n",
1006 get_input_opts(int argc, char **argv)
1008 static struct option lgopts[] = {
1009 {OPT_RULE_FILE, 1, 0, 0},
1010 {OPT_TRACE_FILE, 1, 0, 0},
1011 {OPT_TRACE_NUM, 1, 0, 0},
1012 {OPT_RULE_NUM, 1, 0, 0},
1013 {OPT_MAX_SIZE, 1, 0, 0},
1014 {OPT_TRACE_STEP, 1, 0, 0},
1015 {OPT_BLD_CATEGORIES, 1, 0, 0},
1016 {OPT_RUN_CATEGORIES, 1, 0, 0},
1017 {OPT_ITER_NUM, 1, 0, 0},
1018 {OPT_VERBOSE, 1, 0, 0},
1019 {OPT_SEARCH_ALG, 1, 0, 0},
1020 {OPT_IPV6, 0, 0, 0},
1026 while ((opt = getopt_long(argc, argv, "", lgopts, &opt_idx)) != EOF) {
1029 print_usage(config.prgname);
1030 rte_exit(-EINVAL, "unknown option: %c", opt);
1033 if (strcmp(lgopts[opt_idx].name, OPT_RULE_FILE) == 0) {
1034 config.rule_file = optarg;
1035 } else if (strcmp(lgopts[opt_idx].name, OPT_TRACE_FILE) == 0) {
1036 config.trace_file = optarg;
1037 } else if (strcmp(lgopts[opt_idx].name, OPT_RULE_NUM) == 0) {
1038 config.nb_rules = get_ulong_opt(optarg,
1039 lgopts[opt_idx].name, 1, RTE_ACL_MAX_INDEX + 1);
1040 } else if (strcmp(lgopts[opt_idx].name, OPT_MAX_SIZE) == 0) {
1041 config.max_size = get_ulong_opt(optarg,
1042 lgopts[opt_idx].name, 0, SIZE_MAX);
1043 } else if (strcmp(lgopts[opt_idx].name, OPT_TRACE_NUM) == 0) {
1044 config.nb_traces = get_ulong_opt(optarg,
1045 lgopts[opt_idx].name, 1, UINT32_MAX);
1046 } else if (strcmp(lgopts[opt_idx].name, OPT_TRACE_STEP) == 0) {
1047 config.trace_step = get_ulong_opt(optarg,
1048 lgopts[opt_idx].name, 1, TRACE_STEP_MAX);
1049 } else if (strcmp(lgopts[opt_idx].name,
1050 OPT_BLD_CATEGORIES) == 0) {
1051 config.bld_categories = get_ulong_opt(optarg,
1052 lgopts[opt_idx].name, 1,
1053 RTE_ACL_MAX_CATEGORIES);
1054 } else if (strcmp(lgopts[opt_idx].name,
1055 OPT_RUN_CATEGORIES) == 0) {
1056 config.run_categories = get_ulong_opt(optarg,
1057 lgopts[opt_idx].name, 1,
1058 RTE_ACL_MAX_CATEGORIES);
1059 } else if (strcmp(lgopts[opt_idx].name, OPT_ITER_NUM) == 0) {
1060 config.iter_num = get_ulong_opt(optarg,
1061 lgopts[opt_idx].name, 1, INT32_MAX);
1062 } else if (strcmp(lgopts[opt_idx].name, OPT_VERBOSE) == 0) {
1063 config.verbose = get_ulong_opt(optarg,
1064 lgopts[opt_idx].name, DUMP_NONE, DUMP_MAX);
1065 } else if (strcmp(lgopts[opt_idx].name,
1066 OPT_SEARCH_ALG) == 0) {
1067 get_alg_opt(optarg, lgopts[opt_idx].name);
1068 } else if (strcmp(lgopts[opt_idx].name, OPT_IPV6) == 0) {
1072 config.trace_sz = config.ipv6 ? sizeof(struct ipv6_5tuple) :
1073 sizeof(struct ipv4_5tuple);
1078 main(int argc, char **argv)
1083 ret = rte_eal_init(argc, argv);
1085 rte_panic("Cannot init EAL\n");
1090 config.prgname = argv[0];
1092 get_input_opts(argc, argv);
1093 dump_config(stdout);
1098 if (config.trace_file != NULL)
1101 RTE_LCORE_FOREACH_WORKER(lcore)
1102 rte_eal_remote_launch(search_ip5tuples, NULL, lcore);
1104 search_ip5tuples(NULL);
1106 rte_eal_mp_wait_lcore();
1108 rte_acl_free(config.acx);