Don't group Torrent piece request orders without a storage capacity together

diff --git a/client.go b/client.go
index 8a686767c7f6a8358116156b9df12a91dd51e900..9d0777e40cb559d0c242c1ac961c358763938b23 100644 (file)
--- a/client.go
+++ b/client.go
@@ -75,7 +75,7 @@ type Client struct {
        dopplegangerAddrs map[string]struct{}
        badPeerIPs        map[string]struct{}
        torrents          map[InfoHash]*Torrent
-       pieceRequestOrder map[storage.TorrentCapacity]*request_strategy.PieceRequestOrder
+       pieceRequestOrder map[interface{}]*request_strategy.PieceRequestOrder
 
        acceptLimiter   map[ipStr]int
        dialRateLimiter *rate.Limiter

diff --git a/request-strategy/piece-request-order.go b/request-strategy/piece-request-order.go
index 0b1d6b4e01f9d5b776a0a75e39483f4ab549ffa1..d906b83595e584b03959578dba37a6e7ac2b4f97 100644 (file)
--- a/request-strategy/piece-request-order.go
+++ b/request-strategy/piece-request-order.go
@@ -92,3 +92,7 @@ func (me *PieceRequestOrder) Delete(key PieceRequestOrderKey) {
        delete(me.keys, key)
        // log.Printf("deleting %#v", key)
 }
+
+func (me *PieceRequestOrder) Len() int {
+       return len(me.keys)
+}

diff --git a/requesting.go b/requesting.go
index aaaa4f9cfc7d09b04656d5cb4882dcab96e9add2..c1ffa69762f4e7be678a0284495a428d4eca67c1 100644 (file)
--- a/requesting.go
+++ b/requesting.go
@@ -160,7 +160,7 @@ func (p *Peer) getDesiredRequestState() (desired desiredRequestState) {
        }
        request_strategy.GetRequestablePieces(
                input,
-               p.t.cl.pieceRequestOrder[p.t.storage.Capacity],
+               p.t.getPieceRequestOrder(),
                func(ih InfoHash, pieceIndex int) {
                        if ih != p.t.infoHash {
                                return

diff --git a/torrent-piece-request-order.go b/torrent-piece-request-order.go
index e1ab9670958cfb5a0c472e37dc688fd549e97952..7b1ef97855b2cf66225b5b383b86c9478eec2d40 100644 (file)
--- a/torrent-piece-request-order.go
+++ b/torrent-piece-request-order.go
@@ -1,7 +1,51 @@
 package torrent
 
+import (
+       request_strategy "github.com/anacrolix/torrent/request-strategy"
+)
+
 func (t *Torrent) updatePieceRequestOrder(pieceIndex int) {
-       t.cl.pieceRequestOrder[t.storage.Capacity].Update(
+       t.cl.pieceRequestOrder[t.clientPieceRequestOrderKey()].Update(
                t.pieceRequestOrderKey(pieceIndex),
                t.requestStrategyPieceOrderState(pieceIndex))
 }
+
+func (t *Torrent) clientPieceRequestOrderKey() interface{} {
+       if t.storage.Capacity == nil {
+               return t
+       }
+       return t.storage.Capacity
+}
+
+func (t *Torrent) deletePieceRequestOrder() {
+       cpro := t.cl.pieceRequestOrder
+       key := t.clientPieceRequestOrderKey()
+       pro := cpro[key]
+       for i := 0; i < t.numPieces(); i++ {
+               pro.Delete(t.pieceRequestOrderKey(i))
+       }
+       if pro.Len() == 0 {
+               delete(cpro, key)
+       }
+}
+
+func (t *Torrent) initPieceRequestOrder() {
+       if t.cl.pieceRequestOrder == nil {
+               t.cl.pieceRequestOrder = make(map[interface{}]*request_strategy.PieceRequestOrder)
+       }
+       key := t.clientPieceRequestOrderKey()
+       cpro := t.cl.pieceRequestOrder
+       if cpro[key] == nil {
+               cpro[key] = request_strategy.NewPieceOrder()
+       }
+}
+
+func (t *Torrent) addRequestOrderPiece(i int) {
+       t.cl.pieceRequestOrder[t.clientPieceRequestOrderKey()].Add(
+               t.pieceRequestOrderKey(i),
+               t.requestStrategyPieceOrderState(i))
+}
+
+func (t *Torrent) getPieceRequestOrder() *request_strategy.PieceRequestOrder {
+       return t.cl.pieceRequestOrder[t.clientPieceRequestOrderKey()]
+}

diff --git a/torrent.go b/torrent.go
index db24603bcaa8fb7dae9dd236f80f5e2b93efb6b6..ade7b9338d7771dbec7190ce5ab9d818c97ac3a9 100644 (file)
--- a/torrent.go
+++ b/torrent.go
@@ -437,12 +437,7 @@ func (t *Torrent) pieceRequestOrderKey(i int) request_strategy.PieceRequestOrder
 
 // This seems to be all the follow-up tasks after info is set, that can't fail.
 func (t *Torrent) onSetInfo() {
-       if t.cl.pieceRequestOrder == nil {
-               t.cl.pieceRequestOrder = make(map[storage.TorrentCapacity]*request_strategy.PieceRequestOrder)
-       }
-       if t.cl.pieceRequestOrder[t.storage.Capacity] == nil {
-               t.cl.pieceRequestOrder[t.storage.Capacity] = request_strategy.NewPieceOrder()
-       }
+       t.initPieceRequestOrder()
        for i := range t.pieces {
                p := &t.pieces[i]
                // Need to add availability before updating piece completion, as that may result in conns
@@ -451,9 +446,7 @@ func (t *Torrent) onSetInfo() {
                        panic(p.availability)
                }
                p.availability = int64(t.pieceAvailabilityFromPeers(i))
-               t.cl.pieceRequestOrder[t.storage.Capacity].Add(
-                       t.pieceRequestOrderKey(i),
-                       t.requestStrategyPieceOrderState(i))
+               t.addRequestOrderPiece(i)
                t.updatePieceCompletion(pieceIndex(i))
                if !t.initialPieceCheckDisabled && !p.storageCompletionOk {
                        // t.logger.Printf("piece %s completion unknown, queueing check", p)
@@ -818,12 +811,6 @@ func (t *Torrent) numPiecesCompleted() (num pieceIndex) {
        return pieceIndex(t._completedPieces.GetCardinality())
 }
 
-func (t *Torrent) deletePieceRequestOrder() {
-       for i := 0; i < t.numPieces(); i++ {
-               t.cl.pieceRequestOrder[t.storage.Capacity].Delete(t.pieceRequestOrderKey(i))
-       }
-}
-
 func (t *Torrent) close(wg *sync.WaitGroup) (err error) {
        t.closed.Set()
        if t.storage != nil {