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

Inlineable reader.Seek and no-lock return for bad whence (#577)

* Inlineable reader.Seek and no-lock return for bad whence

Couldn't find an elegant way to early exit on bad whence. Using a closure could reduce code duplication slightly, but it's overkill for only 3 cases.

Note that returning 0 on an invalid whence is the behavior of `strings.Reader` and `bytes.Reader`.

* Update reader.go

Fix usages of eachListener() and make inlineable (#599)

Inlineable methods to access File piecePriority (#601)

Simplify (*Torrent).gotMetainfo (#581)

Remove xerrors dependency (#600)

* Remove xerrors dependency

* Update main.go

Reorder fields to reduce padding in reader (#597)

Reorder some of the fields to reduce the size of `reader`. Not much of a change -- original size was 104 bytes, with changes (moving bool's to the end) the size is 96 bytes. There's also the whole cache-friendly bit -- I tried reordering fields to help here, but I doubt it makes much of a difference.

Some other notes: `sync.Locker` is a 16 byte field. I suggest changing this to something like `*sync.RWMutex` or `*lockWithDeferreds`. This would not only reduce size but would allow access to `RLock`/`RUnlock`.
`pieceRange` could also be shrunk to 8 bytes, but I feel like I'm probably asking for too much lol.

Update ReadCloser interface check to ReadSeekCloser (#595)

Fix http announce of infohash containing ' ' bytes (#591)

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

Don't call Client onClose handlers until torrent storages are closed

Fix Torrent.Drop to wait for storage close without client lock

Avoid allocating memory when checking interface (#588)

Not a big deal, but there isn't a need to allocate an object to check that `*Node` satisfies `bencode.Unmarshaler`.

Optimize peersForPieces allocations for make and sorting

Optimize requesting peerId Uintptr allocation

Disable ensureValidSortedPeersForPieceRequests

Should approximately half the contribution of the parent function to overhead.

Optimize sortPeersForPiece in allocatePendingChunks

Optimize Torrent.worstBadConn

Remove reader.opMu

https://github.com/anacrolix/torrent/issues/553

go fmt ./...

Fix possible misuse of reflect.StringHeader

useTorrentSources: fix http request resource leak (#562)

Clarify ownership of (*Torrent).chunkPool (#583)

Basically bind the lifetime of chunkPool to the torrent by using `sync.Pool` in lieu of `*sync.Pool`. Gives the GC ever so slightly less work to do.

Don't readahead until a read occurs

Make readahead algorithm linear

Add default sqrt readahead algorithm

Extract common Torrent.newReader

Add Webtor to downstream projects

Fix unit tests littering working directory