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
+}