"time"
"unsafe"
+ "github.com/anacrolix/generics/heap"
"github.com/anacrolix/log"
"github.com/anacrolix/multiless"
- "github.com/lispad/go-generics-tools/binheap"
- "github.com/anacrolix/torrent/request-strategy"
- "github.com/anacrolix/torrent/typed-roaring"
+ 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(),
}
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 {
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
}
// Caller-provided allocation for roaring bitmap iteration.
var it typedRoaring.Iterator[RequestIndex]
- request_strategy.GetRequestablePieces(
+ 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
}
}
requestHeap.pieceStates[pieceIndex] = pieceExtra
allowedFast := p.peerAllowedFast.Contains(pieceIndex)
- t.iterUndirtiedRequestIndexesInPiece(&it, pieceIndex, func(r request_strategy.RequestIndex) {
+ 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
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