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)

Inlineable `(*Torrent).AddPeers()` (#622)

Inlineable `DownloadPieces()` and `CancelPieces()` (#623)

Create default constructor for Client (#567)

Allow for certain values to always be properly initialized on construction -- namely the maps for now. I'm currently working on a change that requires a baseline constructor; this change would make the use of `chansync.BroadcastCond` and `chansync.SetOnce` obsolete -- i.e. one can have channel members without worrying about proper initialization/destruction of a `chan struct{}`.

As for why `makeClient` returns a value instead of a pointer: returning a value gives us more options -- you can always take a pointer from a value later on cheaply, and have things moved to the heap if they weren't already. The same can't be said about getting a value back from a pointer. GC also could potentially have less work to do. Plus I personally find ownership to be an important concept (semi-borrowed from rust) -- use of values make ownership clear.

Clarify maximum value of "metadata_size" (#609)

Inlineable `(*File).BytesCompleted()` (#612)

Optimize `LoopbackListenHost()` (#615)

Inlineable (*reader).SetReadAhead and (*reader).Close (#594)

Small fixes that prevent inlining of public functions

Drop bradfitz/iter dependency (#605)

* Drop bradfitz/iter dependency

`range iter.N` looks nice and doesn't allocate, but unfortunately using a `range` expression blocks a function from being inlined wherever it's used (for now). It's not that we need inlining in all cases, but I do think a C-style for loop looks just as nice and is probably clearer to the majority. There also aren't any clear disadvantages to changing (unless you just happen to dislike the look of C)

* Update misc_test.go

* Update rlreader_test.go

* Update torrent_test.go

* Update bench_test.go

* Update client_test.go

* Update iplist_test.go

* Update mse_test.go

* Update peerconn_test.go

* Update peerconn.go

* Update order_test.go

* Update decoder_test.go

* Update main.go

* Update bench-piece-mark-complete.go

* Update main.go

* Update torrent.go

* Update iplist_test.go

* Update main.go

Cheaper byte to string conversion (#602)

Revamped https://github.com/anacrolix/torrent/pull/587