UbiquitousOS
/
OpenCloudOS-Kernel
mirror of https://gitee.com/OpenCloudOS/OpenCloudOS-Kernel.git
11
0
Fork 0
Code Issues Projects Releases Wiki Activity

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: Jens Låås <jens.laas@its.uu.se>
Signed-off-by: Robert Olsson <robert.olsson@its.uu.se>
Signed-off-by: David S. Miller <davem@davemloft.net>
This commit is contained in:
Jens Låås 2009-08-28 23:57:15 -07:00 committed by David S. Miller
parent 8945a808f7
commit 80b71b80df
1 changed files with 23 additions and 72 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

95
net/ipv4/fib_trie.c
View File

@ -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;
}