From 95f73db7e4ede7c87138d78ded312f35db593f9e Mon Sep 17 00:00:00 2001
From: Matt Joiner <anacrolix@gmail.com>
Date: Mon, 31 Oct 2016 16:24:48 +1100
Subject: [PATCH] Ditch the use of generic slices.HeapInterface for finding the
 worst "bad" connection

It's become a bottleneck. Implement it directly using heap.Interface.
---
 torrent.go     |  4 ++--
 worst_conns.go | 31 +++++++++++++++++++++++++++++++
 2 files changed, 33 insertions(+), 2 deletions(-)

diff --git a/torrent.go b/torrent.go
index 280850bb..c8514654 100644
--- a/torrent.go
+++ b/torrent.go
@@ -779,9 +779,9 @@ func (t *Torrent) extentPieces(off, _len int64) (pieces []int) {
 // pieces, or has been in worser half of the established connections for more
 // than a minute.
 func (t *Torrent) worstBadConn() *connection {
-	wcs := slices.HeapInterface(t.worstUnclosedConns(), worseConn)
+	wcs := worseConnSlice{t.worstUnclosedConns()}
 	for wcs.Len() != 0 {
-		c := heap.Pop(wcs).(*connection)
+		c := heap.Pop(&wcs).(*connection)
 		if c.UnwantedChunksReceived >= 6 && c.UnwantedChunksReceived > c.UsefulChunksReceived {
 			return c
 		}
diff --git a/worst_conns.go b/worst_conns.go
index 4085e0c9..dbbc3c27 100644
--- a/worst_conns.go
+++ b/worst_conns.go
@@ -1,5 +1,7 @@
 package torrent
 
+import "container/heap"
+
 func worseConn(l, r *connection) bool {
 	if l.useful() != r.useful() {
 		return r.useful()
@@ -9,3 +11,32 @@ func worseConn(l, r *connection) bool {
 	}
 	return l.completedHandshake.Before(r.completedHandshake)
 }
+
+type worseConnSlice struct {
+	conns []*connection
+}
+
+var _ heap.Interface = &worseConnSlice{}
+
+func (me worseConnSlice) Len() int {
+	return len(me.conns)
+}
+
+func (me worseConnSlice) Less(i, j int) bool {
+	return worseConn(me.conns[i], me.conns[j])
+}
+
+func (me *worseConnSlice) Pop() interface{} {
+	i := len(me.conns) - 1
+	ret := me.conns[i]
+	me.conns = me.conns[:i]
+	return ret
+}
+
+func (me *worseConnSlice) Push(x interface{}) {
+	me.conns = append(me.conns, x.(*connection))
+}
+
+func (me worseConnSlice) Swap(i, j int) {
+	me.conns[i], me.conns[j] = me.conns[j], me.conns[i]
+}