akovalenko/lnd.xprv
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

routing: replace sort.Sort with sort.Slice in router.go

Browse Source 
Use sort.Slice in FindRoutes function in routing/router.go, as part
of the move to use new language features. Remove sortableRoutes type
wrapper for slice of Routes since it is no longer needed to sort routes.
This commit is contained in:
Laura Cressman 2017-09-04 16:58:30 -04:00 committed by Olaoluwa Osuntokun
parent 8822bb11ce
commit 29687f49eb
2 changed files with 14 additions and 37 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

35
routing/pathfind.go
View File

@ -159,41 +159,6 @@ func (r *Route) ToHopPayloads() []sphinx.HopData {
return hopPayloads
}
// sortableRoutes is a slice of routes that can be sorted. Routes are typically
// sorted according to their total cumulative fee within the route. In the case
// that two routes require and identical amount of fees, then the total
// time-lock will be used as the tie breaker.
type sortableRoutes []*Route
// Len returns the number of routes in the collection.
//
// NOTE: This is part of the sort.Interface implementation.
func (s sortableRoutes) Len() int {
return len(s)
}
// Less reports whether the route with index i should sort before the route
// with index j. To make this decision we first check if the total fees
// required for both routes are equal. If so, then we'll let the total time
// lock be the tie breaker. Otherwise, we'll put the route with the lowest
// total fees first.
//
// NOTE: This is part of the sort.Interface implementation.
func (s sortableRoutes) Less(i, j int) bool {
if s[i].TotalFees == s[j].TotalFees {
return s[i].TotalTimeLock < s[j].TotalTimeLock
}
return s[i].TotalFees < s[j].TotalFees
}
// Swap swaps the elements with indexes i and j.
//
// NOTE: This is part of the sort.Interface implementation.
func (s sortableRoutes) Swap(i, j int) {
s[i], s[j] = s[j], s[i]
}
// newRoute returns a fully valid route between the source and target that's
// capable of supporting a payment of `amtToSend` after fees are fully
// computed. If the route is too long, or the selected path cannot support the

16
routing/router.go
View File

@ -869,7 +869,7 @@ func (r *ChannelRouter) FindRoutes(target *btcec.PublicKey,
// each path. During this process, some paths may be discarded if they
// aren't able to support the total satoshis flow once fees have been
// factored in.
validRoutes := make(sortableRoutes, 0, len(shortestPaths))
validRoutes := make([]*Route, 0, len(shortestPaths))
for _, path := range shortestPaths {
// Attempt to make the path into a route. We snip off the first
// hop in the path as it contains a "self-hop" that is inserted
@ -894,7 +894,19 @@ func (r *ChannelRouter) FindRoutes(target *btcec.PublicKey,
// Finally, we'll sort the set of validate routes to optimize for
// lowest total fees, using the required time-lock within the route as
// a tie-breaker.
sort.Sort(validRoutes)
sort.Slice(validRoutes, func(i, j int) bool {
// To make this decision we first check if the total fees
// required for both routes are equal. If so, then we'll let the total time
// lock be the tie breaker. Otherwise, we'll put the route with the lowest
// total fees first.
if validRoutes[i].TotalFees == validRoutes[j].TotalFees {
timeLockI := validRoutes[i].TotalTimeLock
timeLockJ := validRoutes[j].TotalTimeLock
return timeLockI < timeLockJ
}
return validRoutes[i].TotalFees < validRoutes[j].TotalFees
})
log.Debugf("Obtained %v paths sending %v to %x: %v", len(validRoutes),
amt, dest, newLogClosure(func() string {