Simplify request ordering for reversed conditions

Some fixes to pending request accounting

Handle allowed fast while choked when requests already exist in the same piece

Add missing request updates on cancels, rejects

Don't automatically delete requests if we're choked with fast extension

Don't put requests we can't make into the request heap

In particular this should save a lot of overhead if we're choked.

Optimize Peer.peerHasWantedPieces

Optimize request updates due to conn and reader state changes

Extend nominal max requests upper bound to 2048

Use a flat slice for pending request counts

Under heavy load, seems to be 2-3x faster.

Optimize chunk calculations in request strategy

Ignore request strategy run gobs and envrcs

Implement pending requests using BSI

Extract pendingRequests

Add reasons for updateRequests to be triggered

Add pprof labels for request updates and remove Client-wide requester

Remove peer piece inclination and piece request order

These are vestigial data structures used with old request strategy implementations.

Change peer requesting to spread requests out evenly

Log handshook conn run errors with level warning

(cherry picked from commit 7ca7890e9f30307a1f4942e6d987791a142c3cb3)

Ending a conn because we don't like its ID is not an error

(cherry picked from commit 2a5ba846cef9b4e035b3b88698f3e7f7d9d79251)

Fix incomplete Integer.Read

Possibly on read buffer boundaries, this would have caused errant io.ErrUnexpectedEOF.

(cherry picked from commit 22569449dad48e1c5cdeac171625585f8ca976c9)

Only allow chunk size to be set for new Torrents

(cherry picked from commit 09e73e9fce139cd78da48c442e8610501b6fd26b)

Update piece priority after processing piece hash result

Seems to avoid some silly performance issues in triggering request updates due to a piece still pending while being marked.

Pieces being marked should have priority none

Also reorder the checks a bit to favour the cheaper ones.

Add DisableInitialPieceCheck option (#677)

Update requests on unchoke

cmd/torrent: Ensure envpprof.Stop runs before exit

go mod tidy

Fixes broken go doc: https://github.com/golang/go/issues/36811#issuecomment-937401816

Add TorrentStats.PiecesComplete

Fixes https://github.com/anacrolix/torrent/issues/352.

Add to tests for Torrent.Complete

Return errors from Client.Close

Fix comment that seems to mess with GoLand's package structure

Add a flag for Complete

Upgrade Torrent.GotInfo

Update chansync

Apply some lints from GoLand

Remove old-style build tags

Switch Peer.PieceAllowedFast and several request strategy inputs to raw roaring.Bitmaps

This is in preparation to support encoding request strategy run inputs for benchmarking.

go fmt ./...

Change Peer._peerPieces to use raw roaring Bitmap type

The wrapper type was from when roaring didn't support zero-alloc initialization.

Wrap error with %w in mainReadLoop

Fix mainReadLoop benchmark

Fix scheduling overhead in decoding benchmark

Combine peer protocol fuzz targets into one file

More optimizations in peer protocol message decoding

peer_protocol: Use faster form for Integer.{UnmarshalBinary,Read}

Remove an allocation reading message length

Try to avoid allocating buffer

Improvements to decoder fuzzing

Add some fuzzing in peer_protocol

Limit decoded bencode string lengths to 32 bits

Found in fuzzing

Add some fuzzing seeds

Fix parsing of strings that don't fit in memory

Fix fuzz comparison of big.Int

Update fuzz to use new standard library support

Simplify bencode.Decoder.parseStringInterface

bencode: optimize `(*Decoder).parseStringInterface()` (#659)

Inlineable `(*Torrent).BytesMissing()` (#633)

Honestly a name like `BytesLeft` would have been more suitable, but it's too late for that I guess.

Inlineable `addrIndex` (#673)

Eliminate `expect` dependency (#667)

Default to peer requesting disabled

There are some flaws that need to be fixed up before it might be considered the default.

cmd/torrent: Don't make --stats default to --debug's value

Remove unused function

Add ClientConfig.AlwaysWantConns

cmd/torrent: Refactor and set progress interval to 3s

Use an iterator to skip through dirty chunks

cmd/torrent: Include download stats on interrupt

Track dirty chunks in a single bitmap on Torrent

Fix cancellation for global requesting

Merge branch 'master' into peer-requesting

Reduce the diff to master and add peerRequesting feature const

cmd/torrent: Dump download statistics

Filter next requests application for peer state changes

Add NOTES

Store peer requests in a bitmap

When updating requests, only tickle writer if there are no requests pending

Just a quick attempt to reduce load for now. There'll be a much better way to do this.

Do peer requests separately for each peer

Add choking/allowed fast checks to Peer.shouldRequest

Export request_strategy.GetRequestablePieces

goimports doing its thing

Add some tests verifying request map ordering

Update anacrolix/args for bool Flag fix

requesting: Remove some obsoleted condition checks

These shouldn't be necessary since peers were pruned for the ability to allocate chunks to the current piece.

request_strategy.Peer.canRequestPiece performance: Reorder conditions

bencode: get type of `big.Int` without creating instance (#651)

Nope, it doesn't really matter. But anyway, see https://github.com/golang/crypto/blob/c084706c2272f3d44b722e988e70d4a58e60e7f4/cryptobyte/asn1.go#L267

bencode: simplify getting `marshalerType` and `unmarshalerType` (#652)

bencode: Simplify `(*Decoder).parseListInterface()` (#656)

Preserve as much type as possible (it'll be converted to an `interface{}` anyway, but we can return `[]interface{}` instead of `{}interface` here).

Prevent allocation when checking interface (#649)

metainfo: Remove reflection dependency for `Piece.Hash()` (#661)

`copy`  will copy exactly `HashSize` bytes here.

lockWithDeferreds: inlineable Unlock() (#603)

requesting: Filter peers that can't be allocated chunks

Rejig waits between doRequests

Performance improvements in piece requesting

Change torrent capacity to not return a pointer

It's an unnecessary complication for a storage implementer.

Simplify PIece.iterUndirtiedChunks

Pre-allocate request strategy pieces

cmd/torrent: Use anacrolix/args and merge several other cmds in as subcommands

Inlineable `(*Torrent).Seeding()` (#626)

Inlineable `(*Torrent).SetDisplayName()` (#625)

Inlineable `(*Torrent).PieceState()` (#621)