Drop support for go 1.20

[btrtrc.git] / requesting.go

diff --git a/requesting.go b/requesting.go
index b781316d0bf75b6b16d8f7b61b4172cd616b3890..8b9db971b537630e65dd41ca9618f8a708f6a698 100644 (file)
--- a/requesting.go
+++ b/requesting.go
@@ -9,15 +9,22 @@ import (
        "time"
        "unsafe"
 
+       "github.com/anacrolix/generics/heap"
        "github.com/anacrolix/log"
        "github.com/anacrolix/multiless"
-       "github.com/lispad/go-generics-tools/binheap"
 
-       request_strategy "github.com/anacrolix/torrent/request-strategy"
+       requestStrategy "github.com/anacrolix/torrent/request-strategy"
+       typedRoaring "github.com/anacrolix/torrent/typed-roaring"
 )
 
-func (t *Torrent) requestStrategyPieceOrderState(i int) request_strategy.PieceRequestOrderState {
-       return request_strategy.PieceRequestOrderState{
+type (
+       // Since we have to store all the requests in memory, we can't reasonably exceed what could be
+       // indexed with the memory space available.
+       maxRequests = int
+)
+
+func (t *Torrent) requestStrategyPieceOrderState(i int) requestStrategy.PieceRequestOrderState {
+       return requestStrategy.PieceRequestOrderState{
                Priority:     t.piece(i).purePriority(),
                Partial:      t.piecePartiallyDownloaded(i),
                Availability: t.piece(i).availability(),
@@ -63,22 +70,14 @@ func (p *peerId) GobDecode(b []byte) error {
 }
 
 type (
-       RequestIndex   = request_strategy.RequestIndex
-       chunkIndexType = request_strategy.ChunkIndex
+       RequestIndex   = requestStrategy.RequestIndex
+       chunkIndexType = requestStrategy.ChunkIndex
 )
 
 type desiredPeerRequests struct {
        requestIndexes []RequestIndex
        peer           *Peer
-       pieceStates    []request_strategy.PieceRequestOrderState
-}
-
-func (p *desiredPeerRequests) Len() int {
-       return len(p.requestIndexes)
-}
-
-func (p *desiredPeerRequests) Less(i, j int) bool {
-       return p.lessByValue(p.requestIndexes[i], p.requestIndexes[j])
+       pieceStates    []requestStrategy.PieceRequestOrderState
 }
 
 func (p *desiredPeerRequests) lessByValue(leftRequest, rightRequest RequestIndex) bool {
@@ -161,21 +160,6 @@ func (p *desiredPeerRequests) lessByValue(leftRequest, rightRequest RequestIndex
        return ml.Less()
 }
 
-func (p *desiredPeerRequests) Swap(i, j int) {
-       p.requestIndexes[i], p.requestIndexes[j] = p.requestIndexes[j], p.requestIndexes[i]
-}
-
-func (p *desiredPeerRequests) Push(x interface{}) {
-       p.requestIndexes = append(p.requestIndexes, x.(RequestIndex))
-}
-
-func (p *desiredPeerRequests) Pop() interface{} {
-       last := len(p.requestIndexes) - 1
-       x := p.requestIndexes[last]
-       p.requestIndexes = p.requestIndexes[:last]
-       return x
-}
-
 type desiredRequestState struct {
        Requests   desiredPeerRequests
        Interested bool
@@ -195,10 +179,12 @@ func (p *Peer) getDesiredRequestState() (desired desiredRequestState) {
                pieceStates:    t.requestPieceStates,
                requestIndexes: t.requestIndexes,
        }
-       request_strategy.GetRequestablePieces(
+       // Caller-provided allocation for roaring bitmap iteration.
+       var it typedRoaring.Iterator[RequestIndex]
+       requestStrategy.GetRequestablePieces(
                input,
                t.getPieceRequestOrder(),
-               func(ih InfoHash, pieceIndex int, pieceExtra request_strategy.PieceRequestOrderState) {
+               func(ih InfoHash, pieceIndex int, pieceExtra requestStrategy.PieceRequestOrderState) {
                        if ih != t.infoHash {
                                return
                        }
@@ -207,8 +193,7 @@ func (p *Peer) getDesiredRequestState() (desired desiredRequestState) {
                        }
                        requestHeap.pieceStates[pieceIndex] = pieceExtra
                        allowedFast := p.peerAllowedFast.Contains(pieceIndex)
-                       p.t.piece(pieceIndex).undirtiedChunksIter.Iter(func(ci request_strategy.ChunkIndex) {
-                               r := p.t.pieceRequestIndexOffset(pieceIndex) + ci
+                       t.iterUndirtiedRequestIndexesInPiece(&it, pieceIndex, func(r requestStrategy.RequestIndex) {
                                if !allowedFast {
                                        // We must signal interest to request this. TODO: We could set interested if the
                                        // peers pieces (minus the allowed fast set) overlap with our missing pieces if
@@ -264,10 +249,12 @@ func (p *Peer) maybeUpdateActualRequestState() {
 func (p *Peer) applyRequestState(next desiredRequestState) {
        current := &p.requestState
        if !p.setInterested(next.Interested) {
-               panic("insufficient write buffer")
+               return
        }
        more := true
-       requestHeap := binheap.FromSlice(next.Requests.requestIndexes, next.Requests.lessByValue)
+       requestHeap := heap.InterfaceForSlice(&next.Requests.requestIndexes, next.Requests.lessByValue)
+       heap.Init(requestHeap)
+
        t := p.t
        originalRequestCount := current.Requests.GetCardinality()
        // We're either here on a timer, or because we ran out of requests. Both are valid reasons to
@@ -278,7 +265,7 @@ func (p *Peer) applyRequestState(next desiredRequestState) {
                        originalRequestCount, p.needRequestUpdate))
        }
        for requestHeap.Len() != 0 && maxRequests(current.Requests.GetCardinality()+current.Cancelled.GetCardinality()) < p.nominalMaxRequests() {
-               req := requestHeap.Pop()
+               req := heap.Pop(requestHeap)
                existing := t.requestingPeer(req)
                if existing != nil && existing != p {
                        // Don't steal from the poor.