fib: FIB Entry tracking

Instead of all clients directly RR sourcing the entry they are tracking,
use a deidcated 'tracker' object. This tracker object is a entry
delegate and a child of the entry. The clients are then children of the
tracker.
The benefit of this aproach is that each time a new client tracks the
entry it doesn't RR source it. When an entry is sourced all its children
are updated. Thus, new clients tracking an entry is O(n^2). With the
tracker as indirection, the entry is sourced only once.

Type: feature

Change-Id: I5b80bdda6c02057152e5f721e580e786cd840a3b
Signed-off-by: Neale Ranns <nranns@cisco.com>

1 files changed, 108 insertions, 14 deletions

diff --git a/src/vnet/fib/fib_entry_delegate.c b/src/vnet/fib/fib_entry_delegate.c
index 4bf37df0a7e..d7503fbb1b9 100644
--- a/src/vnet/fib/fib_entry_delegate.c
+++ b/src/vnet/fib/fib_entry_delegate.c
@@ -17,17 +17,34 @@
 #include <vnet/fib/fib_entry.h>
 #include <vnet/fib/fib_attached_export.h>
 
+static fib_entry_delegate_t *fib_entry_delegate_pool;
+
+fib_entry_delegate_t *
+fib_entry_delegate_get (index_t fedi)
+{
+    return (pool_elt_at_index(fib_entry_delegate_pool, fedi));
+}
+
+fib_node_index_t
+fib_entry_delegate_get_index (const fib_entry_delegate_t *fed)
+{
+    return (fed - fib_entry_delegate_pool);
+}
+
 static fib_entry_delegate_t *
 fib_entry_delegate_find_i (const fib_entry_t *fib_entry,
                            fib_entry_delegate_type_t type,
                            u32 *index)
 {
     fib_entry_delegate_t *delegate;
+    index_t *fedi;
     int ii;
 
     ii = 0;
-    vec_foreach(delegate, fib_entry->fe_delegates)
+    vec_foreach(fedi, fib_entry->fe_delegates)
     {
+        delegate = fib_entry_delegate_get(*fedi);
+
 	if (delegate->fd_type == type)
 	{
             if (NULL != index)
@@ -45,7 +62,7 @@ fib_entry_delegate_find_i (const fib_entry_t *fib_entry,
 }
 
 fib_entry_delegate_t *
-fib_entry_delegate_get (const fib_entry_t *fib_entry,
+fib_entry_delegate_find (const fib_entry_t *fib_entry,
                         fib_entry_delegate_type_t type)
 {
     return (fib_entry_delegate_find_i(fib_entry, type, NULL));
@@ -63,13 +80,19 @@ fib_entry_delegate_remove (fib_entry_t *fib_entry,
     ASSERT(NULL != fed);
 
     vec_del1(fib_entry->fe_delegates, index);
+
+    pool_put(fib_entry_delegate_pool, fed);
 }
 
 static int
 fib_entry_delegate_cmp_for_sort (void * v1,
                                  void * v2)
 {
-    fib_entry_delegate_t *delegate1 = v1, *delegate2 = v2;
+    fib_entry_delegate_t *delegate1, *delegate2;
+    index_t *fedi1 = v1, *fedi2 = v2;
+
+    delegate1 = fib_entry_delegate_get(*fedi1);
+    delegate2 = fib_entry_delegate_get(*fedi2);
 
     return (delegate1->fd_type - delegate2->fd_type);
 }
@@ -79,12 +102,14 @@ fib_entry_delegate_init (fib_entry_t *fib_entry,
                          fib_entry_delegate_type_t type)
 
 {
-    fib_entry_delegate_t delegate = {
-	.fd_entry_index = fib_entry_get_index(fib_entry),
-	.fd_type = type,
-    };
+    fib_entry_delegate_t *delegate;
+
+    pool_get_zero(fib_entry_delegate_pool, delegate);
+
+    delegate->fd_entry_index = fib_entry_get_index(fib_entry);
+    delegate->fd_type = type;
 
-    vec_add1(fib_entry->fe_delegates, delegate);
+    vec_add1(fib_entry->fe_delegates, delegate - fib_entry_delegate_pool);
     vec_sort_with_function(fib_entry->fe_delegates,
 			   fib_entry_delegate_cmp_for_sort);
 }
@@ -95,14 +120,14 @@ fib_entry_delegate_find_or_add (fib_entry_t *fib_entry,
 {
     fib_entry_delegate_t *delegate;
 
-    delegate = fib_entry_delegate_get(fib_entry, fdt);
+    delegate = fib_entry_delegate_find(fib_entry, fdt);
 
     if (NULL == delegate)
     {
 	fib_entry_delegate_init(fib_entry, fdt);
     }
 
-    return (fib_entry_delegate_get(fib_entry, fdt));
+    return (fib_entry_delegate_find(fib_entry, fdt));
 }
 
 fib_entry_delegate_type_t
@@ -152,6 +177,7 @@ fib_entry_delegate_type_to_chain_type (fib_entry_delegate_type_t fdt)
     case FIB_ENTRY_DELEGATE_ATTACHED_IMPORT:
     case FIB_ENTRY_DELEGATE_ATTACHED_EXPORT:
     case FIB_ENTRY_DELEGATE_BFD:
+    case FIB_ENTRY_DELEGATE_TRACK:
         break;
     }
     ASSERT(0);
@@ -200,7 +226,8 @@ static u8 *
 fib_entry_delegate_fmt_import (const fib_entry_delegate_t *fed,
                                u8 *s)
 {
-    s = format(s, "import:%U", fib_ae_import_format, fed->fd_index);
+    s = format(s, "import:");
+    s = fib_ae_import_format(fed->fd_index, s);
 
     return (s);
 }
@@ -212,7 +239,8 @@ static u8 *
 fib_entry_delegate_fmt_export (const fib_entry_delegate_t *fed,
                                u8 *s)
 {
-    s = format(s, "export:%U", fib_ae_export_format, fed->fd_index);
+    s = format(s, "export:");
+    s = fib_ae_export_format(fed->fd_index, s);
 
     return (s);
 }
@@ -230,6 +258,23 @@ fib_entry_delegate_fmt_bfd (const fib_entry_delegate_t *fed,
 }
 
 /**
+ * Print a delegate that represents tracking
+ */
+static u8 *
+fib_entry_delegate_fmt_track (const fib_entry_delegate_t *fed,
+                              u8 *s)
+{
+    u32 indent = format_get_indent (s);
+
+    s = format(s, "track: sibling:%d", fed->fd_track.fedt_sibling);
+
+    s = format(s, "\n%UChildren:", format_white_space, indent);
+    s = fib_node_children_format(fed->fd_track.fedt_node.fn_children, s);
+
+    return (s);
+}
+
+/**
  * A delegate type to formatter map
  */
 static fib_entry_delegate_format_t fed_formatters[] =
@@ -244,14 +289,63 @@ static fib_entry_delegate_format_t fed_formatters[] =
     [FIB_ENTRY_DELEGATE_ATTACHED_IMPORT] = fib_entry_delegate_fmt_import,
     [FIB_ENTRY_DELEGATE_ATTACHED_EXPORT] = fib_entry_delegate_fmt_export,
     [FIB_ENTRY_DELEGATE_BFD] = fib_entry_delegate_fmt_bfd,
+    [FIB_ENTRY_DELEGATE_TRACK] = fib_entry_delegate_fmt_track,
 };
 
 u8 *
-format_fib_entry_deletegate (u8 * s, va_list * args)
+format_fib_entry_delegate (u8 * s, va_list * args)
 {
     fib_entry_delegate_t *fed;
+    index_t fedi;
 
-    fed = va_arg (*args, fib_entry_delegate_t *);
+    fedi = va_arg (*args, index_t);
+    fed = fib_entry_delegate_get(fedi);
 
     return (fed_formatters[fed->fd_type](fed, s));
 }
+
+static clib_error_t *
+show_fib_entry_delegate_command (vlib_main_t * vm,
+                                 unformat_input_t * input,
+                                 vlib_cli_command_t * cmd)
+{
+    fib_node_index_t fedi;
+
+    if (unformat (input, "%d", &fedi))
+    {
+	/*
+	 * show one in detail
+	 */
+	if (!pool_is_free_index(fib_entry_delegate_pool, fedi))
+	{
+	    vlib_cli_output (vm, "%d@%U",
+			     fedi,
+			     format_fib_entry_delegate, fedi);
+	}
+	else
+	{
+	    vlib_cli_output (vm, "entry %d invalid", fedi);
+	}
+    }
+    else
+    {
+	/*
+	 * show all
+	 */
+	vlib_cli_output (vm, "FIB Entry Delegates:");
+	pool_foreach_index(fedi, fib_entry_delegate_pool,
+        ({
+	    vlib_cli_output (vm, "%d@%U",
+			     fedi,
+			     format_fib_entry_delegate, fedi);
+	}));
+    }
+
+    return (NULL);
+}
+
+VLIB_CLI_COMMAND (show_fib_entry, static) = {
+  .path = "show fib entry-delegate",
+  .function = show_fib_entry_delegate_command,
+  .short_help = "show fib entry delegate",
+};