separate to ensure sync safety

peer/queue/distance.go

@@ -10,61 +10,69 @@ import (
 	u "github.com/jbenet/go-ipfs/util"
 )
 
-// peerDistance tracks a peer and its distance to something else.
-type peerDistance struct {
+// peerMetric tracks a peer and its distance to something else.
+type peerMetric struct {
 	// the peer
 	peer *peer.Peer
 
 	// big.Int for XOR metric
-	distance *big.Int
+	metric *big.Int
 }
 
-// distancePQ implements heap.Interface and PeerQueue
-type distancePQ struct {
-	// from is the Key this PQ measures against
-	from ks.Key
-
-	// peers is a heap of peerDistance items
-	peers []*peerDistance
-
-	sync.RWMutex
-}
+// peerMetricHeap implements a heap of peerDistances
+type peerMetricHeap []*peerMetric
 
-func (pq *distancePQ) Len() int {
-	return len(pq.peers)
+func (ph peerMetricHeap) Len() int {
+	return len(ph)
 }
 
-func (pq *distancePQ) Less(i, j int) bool {
-	return -1 == pq.peers[i].distance.Cmp(pq.peers[j].distance)
+func (ph peerMetricHeap) Less(i, j int) bool {
+	return -1 == ph[i].metric.Cmp(ph[j].metric)
 }
 
-func (pq *distancePQ) Swap(i, j int) {
-	p := pq.peers
-	p[i], p[j] = p[j], p[i]
+func (ph peerMetricHeap) Swap(i, j int) {
+	ph[i], ph[j] = ph[j], ph[i]
 }
 
-func (pq *distancePQ) Push(x interface{}) {
-	item := x.(*peerDistance)
-	pq.peers = append(pq.peers, item)
+func (ph *peerMetricHeap) Push(x interface{}) {
+	item := x.(*peerMetric)
+	*ph = append(*ph, item)
 }
 
-func (pq *distancePQ) Pop() interface{} {
-	old := pq.peers
+func (ph *peerMetricHeap) Pop() interface{} {
+	old := *ph
 	n := len(old)
 	item := old[n-1]
-	pq.peers = old[0 : n-1]
+	*ph = old[0 : n-1]
 	return item
 }
 
+// distancePQ implements heap.Interface and PeerQueue
+type distancePQ struct {
+	// from is the Key this PQ measures against
+	from ks.Key
+
+	// heap is a heap of peerDistance items
+	heap peerMetricHeap
+
+	sync.RWMutex
+}
+
+func (pq *distancePQ) Len() int {
+	pq.Lock()
+	defer pq.Unlock()
+	return len(pq.heap)
+}
+
 func (pq *distancePQ) Enqueue(p *peer.Peer) {
 	pq.Lock()
 	defer pq.Unlock()
 
 	distance := ks.XORKeySpace.Key(p.ID).Distance(pq.from)
 
-	heap.Push(pq, &peerDistance{
-		peer:     p,
-		distance: distance,
+	heap.Push(&pq.heap, &peerMetric{
+		peer:   p,
+		metric: distance,
 	})
 }
 
@@ -72,13 +80,13 @@ func (pq *distancePQ) Dequeue() *peer.Peer {
 	pq.Lock()
 	defer pq.Unlock()
 
-	if len(pq.peers) < 1 {
+	if len(pq.heap) < 1 {
 		panic("called Dequeue on an empty PeerQueue")
 		// will panic internally anyway, but we can help debug here
 	}
 
-	o := heap.Pop(pq)
-	p := o.(*peerDistance)
+	o := heap.Pop(&pq.heap)
+	p := o.(*peerMetric)
 	return p.peer
 }
 
@@ -87,7 +95,7 @@ func (pq *distancePQ) Dequeue() *peer.Peer {
 // XOR as a metric of distance).
 func NewXORDistancePQ(fromKey u.Key) PeerQueue {
 	return &distancePQ{
-		from:  ks.XORKeySpace.Key([]byte(fromKey)),
-		peers: []*peerDistance{},
+		from: ks.XORKeySpace.Key([]byte(fromKey)),
+		heap: peerMetricHeap{},
 	}
 }