Speed up RTC exchange, exclude non-VPN paths from the RTC scheme

1. Add Key(RouteTarget)->uint64.
2. Add map[Key(rt)]map[*Path]{} to globalRib tables for fast making path list by RT.
3. Add map[Key(rt)]int to Adj RTC tables for fast filtering paths by RTs.
4. Add tests on pp.1-3.

Author: Georgy Borodin

internal/pkg/table/adj.go

@@ -31,7 +31,7 @@ type AdjRib struct {
 func NewAdjRib(logger log.Logger, rfList []bgp.RouteFamily) *AdjRib {
  m := make(map[bgp.RouteFamily]*Table)
  for _, f := range rfList {
- m[f] = NewTable(logger, f)
+ m[f] = NewAdjTable(logger, f)
 	}
  return &AdjRib{
  table:    m,
@@ -40,6 +40,11 @@ func NewAdjRib(logger log.Logger, rfList []bgp.RouteFamily) *AdjRib {
 	}
 }
 
+func (adj *AdjRib) HasRTinRtcTable(key uint64) bool {
+ table, found := adj.table[bgp.RF_RTC_UC]
+ return found && table.rtc != nil && table.HasRT(key)
+}
+
 func (adj *AdjRib) Update(pathList []*Path) {
  for _, path := range pathList {
  if path == nil || path.IsEOR() {
@@ -68,15 +73,24 @@ func (adj *AdjRib) Update(pathList []*Path) {
 				}
  if !old.IsRejected() {
  adj.accepted[rf]--
+ if t.rtc != nil {
+ t.rtc.unregister(path, true)
+					}
 				}
 			}
  path.SetDropped(true)
 		} else {
  if idx != -1 {
  if old.IsRejected() && !path.IsRejected() {
  adj.accepted[rf]++
+ if t.rtc != nil {
+ t.rtc.register(path)
+					}
 				} else if !old.IsRejected() && path.IsRejected() {
  adj.accepted[rf]--
+ if t.rtc != nil {
+ t.rtc.unregister(path, true)
+					}
 				}
  if old.Equal(path) {
  path.setTimestamp(old.GetTimestamp())
@@ -86,6 +100,9 @@ func (adj *AdjRib) Update(pathList []*Path) {
  d.knownPathList = append(d.knownPathList, path)
  if !path.IsRejected() {
  adj.accepted[rf]++
+ if t.rtc != nil {
+ t.rtc.register(path)
+					}
 				}
 			}
 		}
@@ -107,6 +124,9 @@ func (adj *AdjRib) UpdateAdjRibOut(pathList []*Path) {
  t := adj.table[path.GetRouteFamily()]
  d := t.getOrCreateDest(path.GetNlri(), 0)
  d.knownPathList = append(d.knownPathList, path)
+ if !path.IsRejected() && t.rtc != nil {
+ t.rtc.register(path)
+		}
 	}
 }
 
@@ -166,7 +186,7 @@ func (adj *AdjRib) Drop(rfList []bgp.RouteFamily) []*Path {
  return false
 	})
  for _, rf := range rfList {
- adj.table[rf] = NewTable(adj.logger, rf)
+ adj.table[rf] = NewAdjTable(adj.logger, rf)
  adj.accepted[rf] = 0
 	}
  return l
@@ -233,7 +253,7 @@ func (adj *AdjRib) MarkLLGRStaleOrDrop(rfList []bgp.RouteFamily) []*Path {
 func (adj *AdjRib) Select(family bgp.RouteFamily, accepted bool, option ...TableSelectOption) (*Table, error) {
  t, ok := adj.table[family]
  if !ok {
- t = NewTable(adj.logger, family)
+ t = NewAdjTable(adj.logger, family)
 	}
  option = append(option, TableSelectOption{adj: true})
  return t.Select(option...)

internal/pkg/table/adj_test.go

@@ -24,6 +24,16 @@ import (
  "github.com/stretchr/testify/assert"
 )
 
+func TestCreateAdjTable(t *testing.T) {
+ table := NewAdjTable(logger, bgp.RF_RTC_UC)
+ assert.NotNil(t, table.rtc)
+ _, checkType := table.rtc.(*routeFamilyRTCMap)
+ assert.True(t, checkType)
+
+ table = NewAdjTable(logger, bgp.RF_FS_IPv4_VPN)
+ assert.Nil(t, table.rtc)
+}
+
 func TestAddPath(t *testing.T) {
  pi := &PeerInfo{}
  attrs := []bgp.PathAttributeInterface{bgp.NewPathAttributeOrigin(0)}
@@ -162,3 +172,53 @@ func TestLLGRStale(t *testing.T) {
  assert.Equal(t, adj.Accepted([]bgp.RouteFamily{family}), 1)
  assert.Equal(t, 2, len(adj.table[family].destinations))
 }
+
+func TestAdjRTC(t *testing.T) {
+ pi := &PeerInfo{}
+ attrs := []bgp.PathAttributeInterface{bgp.NewPathAttributeOrigin(0)}
+
+ rt1, _ := bgp.ParseRouteTarget("65520:1000000")
+ nlri1 := bgp.NewRouteTargetMembershipNLRI(65000, rt1)
+ nlri1.SetPathIdentifier(1)
+ hash1, err := nlri1.RouteTargetKey()
+ assert.Nil(t, err)
+ p1 := NewPath(pi, nlri1, false, attrs, time.Now(), false)
+
+ rt2, _ := bgp.ParseRouteTarget("65520:1000001")
+ nlri2 := bgp.NewRouteTargetMembershipNLRI(65000, rt2)
+ nlri2.SetPathIdentifier(2)
+ hash2, err := nlri2.RouteTargetKey()
+ assert.Nil(t, err)
+ p2 := NewPath(pi, nlri2, false, attrs, time.Now(), false)
+
+ nlri3 := bgp.NewRouteTargetMembershipNLRI(0, nil)
+ nlri3.SetPathIdentifier(3)
+ p3 := NewPath(pi, nlri3, false, attrs, time.Now(), false)
+
+ family := p1.GetRouteFamily()
+ assert.Equal(t, family, bgp.RF_RTC_UC)
+ families := []bgp.RouteFamily{family}
+ adj := NewAdjRib(logger, families)
+
+ adj.Update([]*Path{p1, p2, p3})
+ assert.Equal(t, adj.Count([]bgp.RouteFamily{family}), 3)
+
+ assert.True(t, adj.HasRTinRtcTable(bgp.DefaultRT))
+ assert.True(t, adj.HasRTinRtcTable(hash1))
+ assert.True(t, adj.HasRTinRtcTable(hash2))
+
+ adj.Update([]*Path{p1.Clone(true)})
+ assert.Equal(t, adj.Count([]bgp.RouteFamily{family}), 2)
+ assert.True(t, adj.HasRTinRtcTable(bgp.DefaultRT))
+ assert.True(t, !adj.HasRTinRtcTable(hash1))
+ assert.True(t, adj.HasRTinRtcTable(hash2))
+
+ adj.Update([]*Path{p3.Clone(true)})
+ assert.Equal(t, adj.Count([]bgp.RouteFamily{family}), 1)
+ assert.True(t, !adj.HasRTinRtcTable(bgp.DefaultRT))
+ assert.True(t, adj.HasRTinRtcTable(hash2))
+
+ adj.Update([]*Path{p2.Clone(true)})
+ assert.Equal(t, adj.Count([]bgp.RouteFamily{family}), 0)
+ assert.True(t, !adj.HasRTinRtcTable(hash2))
+}

internal/pkg/table/destination.go

@@ -225,19 +225,23 @@ func (dd *Destination) GetMultiBestPath(id string) []*Path {
 //
 // Modifies destination's state related to stored paths. Removes withdrawn
 // paths from known paths. Also, adds new paths to known paths.
-func (dest *Destination) Calculate(logger log.Logger, newPath *Path) *Update {
+// Returns Update and withdrawn path if it was removed.
+func (dest *Destination) Calculate(logger log.Logger, newPath *Path) (*Update, *Path) {
  oldKnownPathList := make([]*Path, len(dest.knownPathList))
  copy(oldKnownPathList, dest.knownPathList)
+ var withdrawn *Path
 
  if newPath.IsWithdraw {
- p := dest.explicitWithdraw(logger, newPath)
- if p != nil && newPath.IsDropped() {
- if id := p.GetNlri().PathLocalIdentifier(); id != 0 {
- dest.localIdMap.Unflag(uint(id))
+ withdrawn = dest.explicitWithdraw(logger, newPath)
+ if withdrawn != nil {
+ if newPath.IsDropped() {
+ if id := withdrawn.GetNlri().PathLocalIdentifier(); id != 0 {
+ dest.localIdMap.Unflag(uint(id))
+				}
 			}
 		}
 	} else {
- dest.implicitWithdraw(logger, newPath)
+ withdrawn = dest.implicitWithdraw(logger, newPath)
  dest.knownPathList = append(dest.knownPathList, newPath)
 	}
 
@@ -259,7 +263,7 @@ func (dest *Destination) Calculate(logger log.Logger, newPath *Path) *Update {
  return &Update{
  KnownPathList:    l,
  OldKnownPathList: oldKnownPathList,
-	}
+	}, withdrawn
 }
 
 // Removes withdrawn paths.
@@ -316,7 +320,7 @@ func (dest *Destination) explicitWithdraw(logger log.Logger, withdraw *Path) *Pa
 //
 // Known paths will no longer have paths whose new version is present in
 // new paths.
-func (dest *Destination) implicitWithdraw(logger log.Logger, newPath *Path) {
+func (dest *Destination) implicitWithdraw(logger log.Logger, newPath *Path) *Path {
  found := -1
  for i, path := range dest.knownPathList {
  if newPath.NoImplicitWithdraw() {
@@ -341,8 +345,11 @@ func (dest *Destination) implicitWithdraw(logger log.Logger, newPath *Path) {
 		}
 	}
  if found != -1 {
+ p := dest.knownPathList[found]
  dest.knownPathList = append(dest.knownPathList[:found], dest.knownPathList[found+1:]...)
+ return p
 	}
+ return nil
 }
 
 func (dest *Destination) computeKnownBestPath() (*Path, BestPathReason, error) {

internal/pkg/table/destination_test.go

@@ -349,14 +349,17 @@ func TestMultipath(t *testing.T) {
  d := NewDestination(nlri[0], 0)
  d.Calculate(logger, path2)
 
- best, old, multi := d.Calculate(logger, path1).GetChanges(GLOBAL_RIB_NAME, 0, false)
+ dd, oldC := d.Calculate(logger, path1)
+ assert.Nil(t, oldC)
+ best, old, multi := dd.GetChanges(GLOBAL_RIB_NAME, 0, false)
  assert.NotNil(t, best)
  assert.Equal(t, old, path2)
  assert.Equal(t, len(multi), 2)
  assert.Equal(t, len(d.GetKnownPathList(GLOBAL_RIB_NAME, 0)), 2)
 
  path3 := path2.Clone(true)
- dd := d.Calculate(logger, path3)
+ dd, oldC = d.Calculate(logger, path3)
+ assert.Equal(t, path2, oldC)
  best, old, multi = dd.GetChanges(GLOBAL_RIB_NAME, 0, false)
  assert.Nil(t, best)
  assert.Equal(t, old, path1)
@@ -374,7 +377,8 @@ func TestMultipath(t *testing.T) {
 	}
  updateMsg = bgp.NewBGPUpdateMessage(nil, pathAttributes, nlri)
  path4 := ProcessMessage(updateMsg, peer3, time.Now())[0]
- dd = d.Calculate(logger, path4)
+ dd, oldDD := d.Calculate(logger, path4)
+ assert.Nil(t, oldDD)
  best, _, multi = dd.GetChanges(GLOBAL_RIB_NAME, 0, false)
  assert.NotNil(t, best)
  assert.Equal(t, len(multi), 1)
@@ -389,7 +393,8 @@ func TestMultipath(t *testing.T) {
 	}
  updateMsg = bgp.NewBGPUpdateMessage(nil, pathAttributes, nlri)
  path5 := ProcessMessage(updateMsg, peer2, time.Now())[0]
- best, _, multi = d.Calculate(logger, path5).GetChanges(GLOBAL_RIB_NAME, 0, false)
+ dd, _ = d.Calculate(logger, path5)
+ best, _, multi = dd.GetChanges(GLOBAL_RIB_NAME, 0, false)
  assert.NotNil(t, best)
  assert.Equal(t, len(multi), 2)
  assert.Equal(t, len(d.GetKnownPathList(GLOBAL_RIB_NAME, 0)), 3)

internal/pkg/table/path.go

@@ -1037,6 +1037,9 @@ func (lhs *Path) Equal(rhs *Path) bool {
  if rhs == nil {
  return false
 	}
+ if lhs == rhs {
+ return true
+	}
 
  if !lhs.GetSource().Equal(rhs.GetSource()) {
  return false
@@ -1336,3 +1339,78 @@ func nlriToIPNet(nlri bgp.AddrPrefixInterface) *net.IPNet {
 	}
  return nil
 }
+
+func bestPathListForRT(id string, as uint32, withdraw bool, inPaths map[*Path]struct{}, outPaths []*Path) []*Path {
+ for p := range inPaths {
+ if p.IsNexthopInvalid || rsFilter(id, as, p) {
+ continue
+		}
+ if !p.IsWithdraw && withdraw {
+ p = p.Clone(true)
+		}
+ outPaths = append(outPaths, p)
+	}
+ return outPaths
+}
+
+func (t *Table) HasRT(key uint64) bool {
+ if t.rtc == nil {
+ return false
+	}
+ if rtPaths, ok := t.rtc.(*routeFamilyRTCMap); ok {
+ num, found := rtPaths.rts[key]
+ return found && num > 0
+	}
+ return false
+}
+
+func (t *Table) bestPathListForRTMaxLen(rt uint64) int {
+ if t.rtc == nil {
+ return 0
+	}
+ if vpnPaths, ok := t.rtc.(*vpnFamilyRTCMap); ok {
+ if rtTable, found := vpnPaths.rts[rt]; found {
+ return len(rtTable.paths)
+		}
+	}
+ return 0
+}
+
+func (t *Table) getBestsForDetachedRTFromPeer(rt uint64, peerId string, tableId string, as uint32, paths []*Path) []*Path {
+ if t.rtc == nil {
+ // Note: "return paths" means "no new paths are returned".
+ return paths
+	}
+ if vpnPaths, ok := t.rtc.(*vpnFamilyRTCMap); ok {
+ if rtTable, found := vpnPaths.rts[rt]; found {
+ if _, foundId := rtTable.peers[peerId]; foundId {
+ delete(rtTable.peers, peerId)
+ if !rtTable.empty() {
+ return bestPathListForRT(tableId, as, true, rtTable.paths, paths)
+				}
+ delete(vpnPaths.rts, rt)
+			}
+		}
+	}
+ return paths
+}
+
+func (t *Table) getBestsForNewlyAttachedRTtoPeer(rt uint64, peerId string, tableId string, as uint32, paths []*Path) []*Path {
+ if t.rtc == nil {
+ // Note: "return paths" means "no new paths are returned".
+ return paths
+	}
+ if vpnPaths, ok := t.rtc.(*vpnFamilyRTCMap); ok {
+ if rtTable, found := vpnPaths.rts[rt]; !found {
+ rtTable = newVpnFamilyRT()
+ vpnPaths.rts[rt] = rtTable
+ rtTable.peers[peerId] = struct{}{}
+		} else {
+ if _, foundId := rtTable.peers[peerId]; !foundId {
+ rtTable.peers[peerId] = struct{}{}
+ return bestPathListForRT(tableId, as, false, rtTable.paths, paths)
+			}
+		}
+	}
+ return paths
+}