acl: remove unused code
Signed-off-by: Konstantin Ananyev <konstantin.ananyev@intel.com>
This commit is contained in:
Konstantin Ananyev
Thomas Monjalon
parent
cd40cd9195
commit
cd8091d7d8
@ -120,10 +120,6 @@ static int acl_merge_trie(struct acl_build_context *context,
|
||||
struct rte_acl_node *node_a, struct rte_acl_node *node_b,
|
||||
uint32_t level, struct rte_acl_node **node_c);
|
||||
|
||||
static int acl_merge(struct acl_build_context *context,
|
||||
struct rte_acl_node *node_a, struct rte_acl_node *node_b,
|
||||
int move, int a_subset, int level);
|
||||
|
||||
static void
|
||||
acl_deref_ptr(struct acl_build_context *context,
|
||||
struct rte_acl_node *node, int index);
|
||||
@ -414,58 +410,6 @@ acl_intersect_type(const struct rte_acl_bitset *a_bits,
|
||||
return n;
|
||||
}
|
||||
|
||||
/*
|
||||
* Check if all bits in the bitset are on
|
||||
*/
|
||||
static int
|
||||
acl_full(struct rte_acl_node *node)
|
||||
{
|
||||
uint32_t n;
|
||||
bits_t all_bits = -1;
|
||||
|
||||
for (n = 0; n < RTE_ACL_BIT_SET_SIZE; n++)
|
||||
all_bits &= node->values.bits[n];
|
||||
return all_bits == -1;
|
||||
}
|
||||
|
||||
/*
|
||||
* Check if all bits in the bitset are off
|
||||
*/
|
||||
static int
|
||||
acl_empty(struct rte_acl_node *node)
|
||||
{
|
||||
uint32_t n;
|
||||
|
||||
if (node->ref_count == 0) {
|
||||
for (n = 0; n < RTE_ACL_BIT_SET_SIZE; n++) {
|
||||
if (0 != node->values.bits[n])
|
||||
return 0;
|
||||
}
|
||||
return 1;
|
||||
} else {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Compute intersection of A and B
|
||||
* return 1 if there is an intersection else 0.
|
||||
*/
|
||||
static int
|
||||
acl_intersect(struct rte_acl_bitset *a_bits,
|
||||
struct rte_acl_bitset *b_bits,
|
||||
struct rte_acl_bitset *intersect)
|
||||
{
|
||||
uint32_t n;
|
||||
bits_t all_bits = 0;
|
||||
|
||||
for (n = 0; n < RTE_ACL_BIT_SET_SIZE; n++) {
|
||||
intersect->bits[n] = a_bits->bits[n] & b_bits->bits[n];
|
||||
all_bits |= intersect->bits[n];
|
||||
}
|
||||
return all_bits != 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Duplicate a node
|
||||
*/
|
||||
@ -533,63 +477,6 @@ acl_deref_ptr(struct acl_build_context *context,
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Exclude bitset from a node pointer
|
||||
* returns 0 if poiter was deref'd
|
||||
* 1 otherwise.
|
||||
*/
|
||||
static int
|
||||
acl_exclude_ptr(struct acl_build_context *context,
|
||||
struct rte_acl_node *node,
|
||||
int index,
|
||||
struct rte_acl_bitset *b_bits)
|
||||
{
|
||||
int retval = 1;
|
||||
|
||||
/*
|
||||
* remove bitset from node pointer and deref
|
||||
* if the bitset becomes empty.
|
||||
*/
|
||||
if (!acl_exclude(&node->ptrs[index].values,
|
||||
&node->ptrs[index].values,
|
||||
b_bits)) {
|
||||
acl_deref_ptr(context, node, index);
|
||||
node->ptrs[index].ptr = NULL;
|
||||
retval = 0;
|
||||
}
|
||||
|
||||
/* exclude bits from the composite bits for the node */
|
||||
acl_exclude(&node->values, &node->values, b_bits);
|
||||
return retval;
|
||||
}
|
||||
|
||||
/*
|
||||
* Remove a bitset from src ptr and move remaining ptr to dst
|
||||
*/
|
||||
static int
|
||||
acl_move_ptr(struct acl_build_context *context,
|
||||
struct rte_acl_node *dst,
|
||||
struct rte_acl_node *src,
|
||||
int index,
|
||||
struct rte_acl_bitset *b_bits)
|
||||
{
|
||||
int rc;
|
||||
|
||||
if (b_bits != NULL)
|
||||
if (!acl_exclude_ptr(context, src, index, b_bits))
|
||||
return 0;
|
||||
|
||||
/* add src pointer to dst node */
|
||||
rc = acl_add_ptr(context, dst, src->ptrs[index].ptr,
|
||||
&src->ptrs[index].values);
|
||||
if (rc < 0)
|
||||
return rc;
|
||||
|
||||
/* remove ptr from src */
|
||||
acl_exclude_ptr(context, src, index, &src->ptrs[index].values);
|
||||
return 1;
|
||||
}
|
||||
|
||||
/*
|
||||
* acl_exclude rte_acl_bitset from src and copy remaining pointer to dst
|
||||
*/
|
||||
@ -650,203 +537,6 @@ acl_compact_node_ptrs(struct rte_acl_node *node_a)
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* acl_merge helper routine.
|
||||
*/
|
||||
static int
|
||||
acl_merge_intersect(struct acl_build_context *context,
|
||||
struct rte_acl_node *node_a, uint32_t idx_a,
|
||||
struct rte_acl_node *node_b, uint32_t idx_b,
|
||||
int next_move, int level,
|
||||
struct rte_acl_bitset *intersect_ptr)
|
||||
{
|
||||
struct rte_acl_node *node_c;
|
||||
|
||||
/* Duplicate A for intersection */
|
||||
node_c = acl_dup_node(context, node_a->ptrs[idx_a].ptr);
|
||||
|
||||
/* Remove intersection from A */
|
||||
acl_exclude_ptr(context, node_a, idx_a, intersect_ptr);
|
||||
|
||||
/*
|
||||
* Added link from A to C for all transitions
|
||||
* in the intersection
|
||||
*/
|
||||
if (acl_add_ptr(context, node_a, node_c, intersect_ptr) < 0)
|
||||
return -1;
|
||||
|
||||
/* merge B->node into C */
|
||||
return acl_merge(context, node_c, node_b->ptrs[idx_b].ptr, next_move,
|
||||
0, level + 1);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Merge the children of nodes A and B together.
|
||||
*
|
||||
* if match node
|
||||
* For each category
|
||||
* node A result = highest priority result
|
||||
* if any pointers in A intersect with any in B
|
||||
* For each intersection
|
||||
* C = copy of node that A points to
|
||||
* remove intersection from A pointer
|
||||
* add a pointer to A that points to C for the intersection
|
||||
* Merge C and node that B points to
|
||||
* Compact the pointers in A and B
|
||||
* if move flag
|
||||
* If B has only one reference
|
||||
* Move B pointers to A
|
||||
* else
|
||||
* Copy B pointers to A
|
||||
*/
|
||||
static int
|
||||
acl_merge(struct acl_build_context *context,
|
||||
struct rte_acl_node *node_a, struct rte_acl_node *node_b,
|
||||
int move, int a_subset, int level)
|
||||
{
|
||||
uint32_t n, m, ptrs_a, ptrs_b;
|
||||
uint32_t min_add_a, min_add_b;
|
||||
int intersect_type;
|
||||
int node_intersect_type;
|
||||
int b_full, next_move, rc;
|
||||
struct rte_acl_bitset intersect_values;
|
||||
struct rte_acl_bitset intersect_ptr;
|
||||
|
||||
min_add_a = 0;
|
||||
min_add_b = 0;
|
||||
intersect_type = 0;
|
||||
node_intersect_type = 0;
|
||||
|
||||
if (level == 0)
|
||||
a_subset = 1;
|
||||
|
||||
/*
|
||||
* Resolve match priorities
|
||||
*/
|
||||
if (node_a->match_flag != 0 || node_b->match_flag != 0) {
|
||||
|
||||
if (node_a->match_flag == 0 || node_b->match_flag == 0)
|
||||
RTE_LOG(ERR, ACL, "Not both matches\n");
|
||||
|
||||
if (node_b->match_flag < node_a->match_flag)
|
||||
RTE_LOG(ERR, ACL, "Not same match\n");
|
||||
|
||||
for (n = 0; n < context->cfg.num_categories; n++) {
|
||||
if (node_a->mrt->priority[n] <
|
||||
node_b->mrt->priority[n]) {
|
||||
node_a->mrt->priority[n] =
|
||||
node_b->mrt->priority[n];
|
||||
node_a->mrt->results[n] =
|
||||
node_b->mrt->results[n];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* If the two node transitions intersect then merge the transitions.
|
||||
* Check intersection for entire node (all pointers)
|
||||
*/
|
||||
node_intersect_type = acl_intersect_type(&node_a->values,
|
||||
&node_b->values,
|
||||
&intersect_values);
|
||||
|
||||
if (node_intersect_type & ACL_INTERSECT) {
|
||||
|
||||
b_full = acl_full(node_b);
|
||||
|
||||
min_add_b = node_b->min_add;
|
||||
node_b->min_add = node_b->num_ptrs;
|
||||
ptrs_b = node_b->num_ptrs;
|
||||
|
||||
min_add_a = node_a->min_add;
|
||||
node_a->min_add = node_a->num_ptrs;
|
||||
ptrs_a = node_a->num_ptrs;
|
||||
|
||||
for (n = 0; n < ptrs_a; n++) {
|
||||
for (m = 0; m < ptrs_b; m++) {
|
||||
|
||||
if (node_a->ptrs[n].ptr == NULL ||
|
||||
node_b->ptrs[m].ptr == NULL ||
|
||||
node_a->ptrs[n].ptr ==
|
||||
node_b->ptrs[m].ptr)
|
||||
continue;
|
||||
|
||||
intersect_type = acl_intersect_type(
|
||||
&node_a->ptrs[n].values,
|
||||
&node_b->ptrs[m].values,
|
||||
&intersect_ptr);
|
||||
|
||||
/* If this node is not a 'match' node */
|
||||
if ((intersect_type & ACL_INTERSECT) &&
|
||||
(context->cfg.num_categories != 1 ||
|
||||
!(node_a->ptrs[n].ptr->match_flag))) {
|
||||
|
||||
/*
|
||||
* next merge is a 'move' pointer,
|
||||
* if this one is and B is a
|
||||
* subset of the intersection.
|
||||
*/
|
||||
next_move = move &&
|
||||
(intersect_type &
|
||||
ACL_INTERSECT_B) == 0;
|
||||
|
||||
if (a_subset && b_full) {
|
||||
rc = acl_merge(context,
|
||||
node_a->ptrs[n].ptr,
|
||||
node_b->ptrs[m].ptr,
|
||||
next_move,
|
||||
1, level + 1);
|
||||
if (rc != 0)
|
||||
return rc;
|
||||
} else {
|
||||
rc = acl_merge_intersect(
|
||||
context, node_a, n,
|
||||
node_b, m, next_move,
|
||||
level, &intersect_ptr);
|
||||
if (rc != 0)
|
||||
return rc;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Compact pointers */
|
||||
node_a->min_add = min_add_a;
|
||||
acl_compact_node_ptrs(node_a);
|
||||
node_b->min_add = min_add_b;
|
||||
acl_compact_node_ptrs(node_b);
|
||||
|
||||
/*
|
||||
* Either COPY or MOVE pointers from B to A
|
||||
*/
|
||||
acl_intersect(&node_a->values, &node_b->values, &intersect_values);
|
||||
|
||||
if (move && node_b->ref_count == 1) {
|
||||
for (m = 0; m < node_b->num_ptrs; m++) {
|
||||
if (node_b->ptrs[m].ptr != NULL &&
|
||||
acl_move_ptr(context, node_a, node_b, m,
|
||||
&intersect_values) < 0)
|
||||
return -1;
|
||||
}
|
||||
} else {
|
||||
for (m = 0; m < node_b->num_ptrs; m++) {
|
||||
if (node_b->ptrs[m].ptr != NULL &&
|
||||
acl_copy_ptr(context, node_a, node_b, m,
|
||||
&intersect_values) < 0)
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Free node if its empty (no longer used)
|
||||
*/
|
||||
if (acl_empty(node_b))
|
||||
acl_free_node(context, node_b);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int
|
||||
acl_resolve_leaf(struct acl_build_context *context,
|
||||
struct rte_acl_node *node_a,
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user