acl: introduce config parameter for performance/space trade-off

[dpdk.git] / lib / librte_acl / rte_acl.c

diff --git a/lib/librte_acl/rte_acl.c b/lib/librte_acl/rte_acl.c
index 7c288bd..7d10301 100644 (file)
--- a/lib/librte_acl/rte_acl.c
+++ b/lib/librte_acl/rte_acl.c
@@ -38,6 +38,90 @@
 
 TAILQ_HEAD(rte_acl_list, rte_tailq_entry);
 
+/*
+ * If the compiler doesn't support AVX2 instructions,
+ * then the dummy one would be used instead for AVX2 classify method.
+ */
+int __attribute__ ((weak))
+rte_acl_classify_avx2(__rte_unused const struct rte_acl_ctx *ctx,
+       __rte_unused const uint8_t **data,
+       __rte_unused uint32_t *results,
+       __rte_unused uint32_t num,
+       __rte_unused uint32_t categories)
+{
+       return -ENOTSUP;
+}
+
+static const rte_acl_classify_t classify_fns[] = {
+       [RTE_ACL_CLASSIFY_DEFAULT] = rte_acl_classify_scalar,
+       [RTE_ACL_CLASSIFY_SCALAR] = rte_acl_classify_scalar,
+       [RTE_ACL_CLASSIFY_SSE] = rte_acl_classify_sse,
+       [RTE_ACL_CLASSIFY_AVX2] = rte_acl_classify_avx2,
+};
+
+/* by default, use always available scalar code path. */
+static enum rte_acl_classify_alg rte_acl_default_classify =
+       RTE_ACL_CLASSIFY_SCALAR;
+
+static void
+rte_acl_set_default_classify(enum rte_acl_classify_alg alg)
+{
+       rte_acl_default_classify = alg;
+}
+
+extern int
+rte_acl_set_ctx_classify(struct rte_acl_ctx *ctx, enum rte_acl_classify_alg alg)
+{
+       if (ctx == NULL || (uint32_t)alg >= RTE_DIM(classify_fns))
+               return -EINVAL;
+
+       ctx->alg = alg;
+       return 0;
+}
+
+/*
+ * Select highest available classify method as default one.
+ * Note that CLASSIFY_AVX2 should be set as a default only
+ * if both conditions are met:
+ * at build time compiler supports AVX2 and target cpu supports AVX2.
+ */
+static void __attribute__((constructor))
+rte_acl_init(void)
+{
+       enum rte_acl_classify_alg alg = RTE_ACL_CLASSIFY_DEFAULT;
+
+#ifdef CC_AVX2_SUPPORT
+       if (rte_cpu_get_flag_enabled(RTE_CPUFLAG_AVX2))
+               alg = RTE_ACL_CLASSIFY_AVX2;
+       else if (rte_cpu_get_flag_enabled(RTE_CPUFLAG_SSE4_1))
+#else
+       if (rte_cpu_get_flag_enabled(RTE_CPUFLAG_SSE4_1))
+#endif
+               alg = RTE_ACL_CLASSIFY_SSE;
+
+       rte_acl_set_default_classify(alg);
+}
+
+int
+rte_acl_classify_alg(const struct rte_acl_ctx *ctx, const uint8_t **data,
+       uint32_t *results, uint32_t num, uint32_t categories,
+       enum rte_acl_classify_alg alg)
+{
+       if (categories != 1 &&
+                       ((RTE_ACL_RESULTS_MULTIPLIER - 1) & categories) != 0)
+               return -EINVAL;
+
+       return classify_fns[alg](ctx, data, results, num, categories);
+}
+
+int
+rte_acl_classify(const struct rte_acl_ctx *ctx, const uint8_t **data,
+       uint32_t *results, uint32_t num, uint32_t categories)
+{
+       return rte_acl_classify_alg(ctx, data, results, num, categories,
+               ctx->alg);
+}
+
 struct rte_acl_ctx *
 rte_acl_find_existing(const char *name)
 {
@@ -151,7 +235,7 @@ rte_acl_create(const struct rte_acl_param *param)
                        goto exit;
                }
 
-               ctx = rte_zmalloc_socket(name, sz, CACHE_LINE_SIZE, param->socket_id);
+               ctx = rte_zmalloc_socket(name, sz, RTE_CACHE_LINE_SIZE, param->socket_id);
 
                if (ctx == NULL) {
                        RTE_LOG(ERR, ACL,
@@ -165,6 +249,7 @@ rte_acl_create(const struct rte_acl_param *param)
                ctx->max_rules = param->max_rule_num;
                ctx->rule_sz = param->rule_size;
                ctx->socket_id = param->socket_id;
+               ctx->alg = rte_acl_default_classify;
                snprintf(ctx->name, sizeof(ctx->name), "%s", param->name);
 
                te->data = (void *) ctx;
@@ -261,6 +346,8 @@ rte_acl_dump(const struct rte_acl_ctx *ctx)
        if (!ctx)
                return;
        printf("acl context <%s>@%p\n", ctx->name, ctx);
+       printf("  socket_id=%"PRId32"\n", ctx->socket_id);
+       printf("  alg=%"PRId32"\n", ctx->alg);
        printf("  max_rules=%"PRIu32"\n", ctx->max_rules);
        printf("  rule_size=%"PRIu32"\n", ctx->rule_sz);
        printf("  num_rules=%"PRIu32"\n", ctx->num_rules);
@@ -456,6 +543,7 @@ rte_acl_ipv4vlan_build(struct rte_acl_ctx *ctx,
        if (ctx == NULL || layout == NULL)
                return -EINVAL;
 
+       memset(&cfg, 0, sizeof(cfg));
        acl_ipv4vlan_config(&cfg, layout, num_categories);
        return rte_acl_build(ctx, &cfg);
 }