Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 80b71b80 authored by Jens Låås's avatar Jens Låås Committed by David S. Miller
Browse files

fib_trie: resize rework 



Here is rework and cleanup of the resize function.

Some bugs we had. We were using ->parent when we should use 
node_parent(). Also we used ->parent which is not assigned by
inflate in inflate loop.

Also a fix to set thresholds to power 2 to fit halve 
and double strategy.

max_resize is renamed to max_work which better indicates
it's function.

Reaching max_work is not an error, so warning is removed. 
max_work only limits amount of work done per resize.
(limits CPU-usage, outstanding memory etc).

The clean-up makes it relatively easy to add fixed sized 
root-nodes if we would like to decrease the memory pressure
on routers with large routing tables and dynamic routing.
If we'll need that...

Its been tested with 280k routes.

Work done together with Robert Olsson.

Signed-off-by: default avatarJens Låås <jens.laas@its.uu.se>
Signed-off-by: default avatarRobert Olsson <robert.olsson@its.uu.se>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent 8945a808

net/ipv4/fib_trie.c

+23 −72
Original line number Diff line number Diff line
@@ -48,7 +48,7 @@ 
 *		Patrick McHardy <kaber@trash.net>

 */



#define VERSION "0.408"

#define VERSION "0.409"



#include <asm/uaccess.h>

#include <asm/system.h>
@@ -325,10 +325,7 @@ static inline void check_tnode(const struct tnode *tn) 
static const int halve_threshold = 25;

static const int inflate_threshold = 50;

static const int halve_threshold_root = 15;

static const int inflate_threshold_root = 25;



static int inflate_threshold_root_fix;

#define INFLATE_FIX_MAX 10	/* a comment in resize() */

static const int inflate_threshold_root = 30;



static void __alias_free_mem(struct rcu_head *head)

{
@@ -516,14 +513,14 @@ static void tnode_put_child_reorg(struct tnode *tn, int i, struct node *n, 
	rcu_assign_pointer(tn->child[i], n);

}



#define MAX_WORK 10

static struct node *resize(struct trie *t, struct tnode *tn)

{

	int i;

	int err = 0;

	struct tnode *old_tn;

	int inflate_threshold_use;

	int halve_threshold_use;

	int max_resize;

	int max_work;



	if (!tn)

		return NULL;
@@ -538,18 +535,7 @@ static struct node *resize(struct trie *t, struct tnode *tn) 
	}

	/* One child */

	if (tn->empty_children == tnode_child_length(tn) - 1)

		for (i = 0; i < tnode_child_length(tn); i++) {

			struct node *n;



			n = tn->child[i];

			if (!n)

				continue;



			/* compress one level */

			node_set_parent(n, NULL);

			tnode_free_safe(tn);

			return n;

		}

		goto one_child;

	/*

	 * Double as long as the resulting node has a number of

	 * nonempty nodes that are above the threshold.
@@ -618,15 +604,17 @@ static struct node *resize(struct trie *t, struct tnode *tn) 


	/* Keep root node larger  */



	if (!tn->parent)

		inflate_threshold_use = inflate_threshold_root +

					inflate_threshold_root_fix;

	else

	if (!node_parent((struct node*) tn)) {

		inflate_threshold_use = inflate_threshold_root;

		halve_threshold_use = halve_threshold_root;

	}

	else {

		inflate_threshold_use = inflate_threshold;

		halve_threshold_use = halve_threshold;

	}



	err = 0;

	max_resize = 10;

	while ((tn->full_children > 0 &&  max_resize-- &&

	max_work = MAX_WORK;

	while ((tn->full_children > 0 &&  max_work-- &&

		50 * (tn->full_children + tnode_child_length(tn)

		      - tn->empty_children)

		>= inflate_threshold_use * tnode_child_length(tn))) {
@@ -643,47 +631,19 @@ static struct node *resize(struct trie *t, struct tnode *tn) 
		}

	}



	if (max_resize < 0) {

		if (!tn->parent) {

			/*

			 * It was observed that during large updates even

			 * inflate_threshold_root = 35 might be needed to avoid

			 * this warning; but it should be temporary, so let's

			 * try to handle this automatically.

			 */

			if (inflate_threshold_root_fix < INFLATE_FIX_MAX)

				inflate_threshold_root_fix++;

			else

				pr_warning("Fix inflate_threshold_root."

					   " Now=%d size=%d bits fix=%d\n",

					   inflate_threshold_root, tn->bits,

					   inflate_threshold_root_fix);

		} else {

			pr_warning("Fix inflate_threshold."

				   " Now=%d size=%d bits\n",

				   inflate_threshold, tn->bits);

		}

	} else if (max_resize > 3 && !tn->parent && inflate_threshold_root_fix)

		inflate_threshold_root_fix--;



	check_tnode(tn);



	/* Return if at least one inflate is run */

	if( max_work != MAX_WORK)

		return (struct node *) tn;



	/*

	 * Halve as long as the number of empty children in this

	 * node is above threshold.

	 */





	/* Keep root node larger  */



	if (!tn->parent)

		halve_threshold_use = halve_threshold_root;

	else

		halve_threshold_use = halve_threshold;



	err = 0;

	max_resize = 10;

	while (tn->bits > 1 &&  max_resize-- &&

	max_work = MAX_WORK;

	while (tn->bits > 1 &&  max_work-- &&

	       100 * (tnode_child_length(tn) - tn->empty_children) <

	       halve_threshold_use * tnode_child_length(tn)) {
@@ -698,19 +658,10 @@ static struct node *resize(struct trie *t, struct tnode *tn) 
		}

	}



	if (max_resize < 0) {

		if (!tn->parent)

			pr_warning("Fix halve_threshold_root."

				   " Now=%d size=%d bits\n",

				   halve_threshold_root, tn->bits);

		else

			pr_warning("Fix halve_threshold."

				   " Now=%d size=%d bits\n",

				   halve_threshold, tn->bits);

	}



	/* Only one child remains */

	if (tn->empty_children == tnode_child_length(tn) - 1)

	if (tn->empty_children == tnode_child_length(tn) - 1) {

one_child:

		for (i = 0; i < tnode_child_length(tn); i++) {

			struct node *n;
@@ -724,7 +675,7 @@ static struct node *resize(struct trie *t, struct tnode *tn) 
			tnode_free_safe(tn);

			return n;

		}



	}

	return (struct node *) tn;

}