premiere
/
premiere-libtorrent
2
2
Fork 1
Code Issues Pull Requests Releases Wiki Activity

add typesafety to piece_picker torrent_peer pointers. and fix a few incorrect uses

This commit is contained in:
arvidn 2015-08-18 04:25:13 -04:00
parent 9b650bc30b
commit f6b86dc4b5
6 changed files with 115 additions and 110 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

54
include/libtorrent/piece_picker.hpp
View File

@ -72,6 +72,7 @@ namespace libtorrent
class peer_connection;
struct bitfield;
struct counters;
struct torrent_peer;
struct TORRENT_EXTRA_EXPORT piece_block
{
@ -118,9 +119,8 @@ namespace libtorrent
{
block_info(): peer(0), num_peers(0), state(state_none) {}
// the peer this block was requested or
// downloaded from. This is a pointer to
// a torrent_peer object
void* peer;
// downloaded from.
torrent_peer* peer;
// the number of peers that has this block in their
// download or request queues
unsigned num_peers:14;
@ -130,7 +130,7 @@ namespace libtorrent
#if TORRENT_USE_ASSERTS
// to allow verifying the invariant of blocks belonging to the right piece
int piece_index;
std::set<void*> peers;
std::set<torrent_peer*> peers;
#endif
};
@ -216,21 +216,21 @@ namespace libtorrent
// increases the peer count for the given piece
// (is used when a HAVE message is received)
void inc_refcount(int index, const void* peer);
void dec_refcount(int index, const void* peer);
void inc_refcount(int index, const torrent_peer* peer);
void dec_refcount(int index, const torrent_peer* peer);
// increases the peer count for the given piece
// (is used when a BITFIELD message is received)
void inc_refcount(bitfield const& bitmask, const void* peer);
void inc_refcount(bitfield const& bitmask, const torrent_peer* peer);
// decreases the peer count for the given piece
// (used when a peer disconnects)
void dec_refcount(bitfield const& bitmask, const void* peer);
void dec_refcount(bitfield const& bitmask, const torrent_peer* peer);
// these will increase and decrease the peer count
// of all pieces. They are used when seeds join
// or leave the swarm.
void inc_refcount_all(const void* peer);
void dec_refcount_all(const void* peer);
void inc_refcount_all(const torrent_peer* peer);
void dec_refcount_all(const torrent_peer* peer);
// This indicates that we just received this piece
// it means that the refcounter will indicate that
@ -297,7 +297,7 @@ namespace libtorrent
// (i.e. higher overhead per request).
void pick_pieces(bitfield const& pieces
, std::vector<piece_block>& interesting_blocks, int num_blocks
, int prefer_contiguous_blocks, void* peer
, int prefer_contiguous_blocks, torrent_peer* peer
, int options, std::vector<int> const& suggested_pieces
, int num_peers
, counters& pc
@ -314,7 +314,7 @@ namespace libtorrent
, std::vector<piece_block>& backup_blocks
, std::vector<piece_block>& backup_blocks2
, int num_blocks, int prefer_contiguous_blocks
, void* peer, std::vector<int> const& ignore
, torrent_peer* peer, std::vector<int> const& ignore
, int options) const;
// picks blocks only from downloading pieces
@ -324,12 +324,12 @@ namespace libtorrent
, std::vector<piece_block>& backup_blocks
, std::vector<piece_block>& backup_blocks2
, int num_blocks, int prefer_contiguous_blocks
, void* peer
, torrent_peer* peer
, int options) const;
// clears the peer pointer in all downloading pieces with this
// peer pointer
void clear_peer(void* peer);
void clear_peer(torrent_peer* peer);
#if TORRENT_USE_INVARIANT_CHECKS
// this is an invariant check
@ -349,15 +349,15 @@ namespace libtorrent
// marks this piece-block as queued for downloading
// options are flags from options_t.
bool mark_as_downloading(piece_block block, void* peer
bool mark_as_downloading(piece_block block, torrent_peer* peer
, int options = 0);
// returns true if the block was marked as writing,
// and false if the block is already finished or writing
bool mark_as_writing(piece_block block, void* peer);
bool mark_as_writing(piece_block block, torrent_peer* peer);
void mark_as_canceled(piece_block block, void* peer);
void mark_as_finished(piece_block block, void* peer);
void mark_as_canceled(piece_block block, torrent_peer* peer);
void mark_as_finished(piece_block block, torrent_peer* peer);
// prevent blocks from being picked from this piece.
// to unlock the piece, call restore_piece() on it
@ -390,7 +390,7 @@ namespace libtorrent
// clears the given piece's download flag
// this means that this piece-block can be picked again
void abort_download(piece_block block, void* peer = 0);
void abort_download(piece_block block, torrent_peer* peer = 0);
// returns true if all blocks in this piece are finished
// or if we have the piece
@ -409,7 +409,7 @@ namespace libtorrent
// return the peer pointers to all peers that participated in
// this piece
void get_downloaders(std::vector<void*>& d, int index) const;
void get_downloaders(std::vector<torrent_peer*>& d, int index) const;
std::vector<piece_picker::downloading_piece> get_download_queue() const;
int get_download_queue_size() const;
@ -417,7 +417,7 @@ namespace libtorrent
void get_download_queue_sizes(int* partial
, int* full, int* finished, int* zero_prio) const;
void* get_downloader(piece_block block) const;
torrent_peer* get_downloader(piece_block block) const;
// the number of filtered pieces we don't have
int num_filtered() const { return m_num_filtered; }
@ -449,7 +449,7 @@ namespace libtorrent
void verify_pick(std::vector<piece_block> const& picked
, bitfield const& bits) const;
void check_peer_invariant(bitfield const& have, void const* p) const;
void check_peer_invariant(bitfield const& have, torrent_peer const* p) const;
void check_invariant(const torrent* t = 0) const;
#endif
#if defined TORRENT_PICKER_LOG || defined TORRENT_DEBUG
@ -483,7 +483,7 @@ namespace libtorrent
boost::tuple<bool, bool, int, int> requested_from(
piece_picker::downloading_piece const& p
, int num_blocks_in_piece, void* peer) const;
, int num_blocks_in_piece, torrent_peer* peer) const;
bool can_pick(int piece, bitfield const& bitmask) const;
bool is_piece_free(int piece, bitfield const& bitmask) const;
@ -617,7 +617,7 @@ namespace libtorrent
#ifdef TORRENT_DEBUG_REFCOUNTS
// all the peers that have this piece
std::set<const void*> have_peers;
std::set<const torrent_peer*> have_peers;
#endif
enum
@ -639,18 +639,18 @@ namespace libtorrent
max_peer_count = 0xffff
#endif
};
bool have() const { return index == we_have_index; }
void set_have() { index = we_have_index; TORRENT_ASSERT(have()); }
void set_not_have() { index = 0; TORRENT_ASSERT(!have()); }
bool downloading() const { return download_state != piece_open; }
bool filtered() const { return piece_priority == filter_priority; }
// this function returns the effective priority of the piece. It's
// actually the sort order of this piece compared to other pieces. A
// lower index means it will be picked before a piece with a higher
// index.
// index.
// The availability of the piece (the number of peers that have this
// piece) is fundamentally controlling the priority. It's multiplied
// by 3 to form 3 levels of priority for each availability.

16
src/peer_connection.cpp
View File

@ -721,7 +721,7 @@ namespace libtorrent
#if TORRENT_USE_INVARIANT_CHECKS
if (t && t->has_picker())
t->picker().check_peer_invariant(m_have_piece, this);
t->picker().check_peer_invariant(m_have_piece, peer_info_struct());
#endif
if (t->is_upload_only()) send_not_interested();
else t->peer_is_interesting(*this);
@ -1894,7 +1894,7 @@ namespace libtorrent
#if TORRENT_USE_INVARIANT_CHECKS
if (t && t->has_picker())
t->picker().check_peer_invariant(m_have_piece, this);
t->picker().check_peer_invariant(m_have_piece, peer_info_struct());
#endif
}
@ -2057,7 +2057,7 @@ namespace libtorrent
#if TORRENT_USE_INVARIANT_CHECKS
if (t && t->has_picker())
t->picker().check_peer_invariant(m_have_piece, this);
t->picker().check_peer_invariant(m_have_piece, peer_info_struct());
#endif
return;
}
@ -2084,7 +2084,7 @@ namespace libtorrent
#if TORRENT_USE_INVARIANT_CHECKS
if (t && t->has_picker())
t->picker().check_peer_invariant(m_have_piece, this);
t->picker().check_peer_invariant(m_have_piece, peer_info_struct());
#endif
// this will cause us to send the INTERESTED message
@ -2849,13 +2849,13 @@ namespace libtorrent
int num_blocks = t->picker().blocks_in_piece(piece);
if (st.requested > 0 && st.writing + st.finished + st.requested == num_blocks)
{
std::vector<void*> d;
std::vector<torrent_peer*> d;
t->picker().get_downloaders(d, piece);
if (d.size() == 1)
{
// only make predictions if all remaining
// blocks are requested from the same peer
torrent_peer* peer = static_cast<torrent_peer*>(d[0]);
torrent_peer* peer = d[0];
if (peer->connection)
{
// we have a connection. now, what is the current
@ -3145,7 +3145,7 @@ namespace libtorrent
#if TORRENT_USE_INVARIANT_CHECKS
if (t && t->has_picker())
t->picker().check_peer_invariant(m_have_piece, this);
t->picker().check_peer_invariant(m_have_piece, peer_info_struct());
#endif
TORRENT_ASSERT(m_have_piece.all_set());
@ -6505,7 +6505,7 @@ namespace libtorrent
#if TORRENT_USE_INVARIANT_CHECKS \
&& !defined TORRENT_NO_EXPENSIVE_INVARIANT_CHECK
if (t && t->has_picker() && !m_disconnecting)
t->picker().check_peer_invariant(m_have_piece, this);
t->picker().check_peer_invariant(m_have_piece, peer_info_struct());
#endif
if (!m_disconnect_started && m_initialized)

60
src/piece_picker.cpp
View File

@ -349,7 +349,7 @@ namespace libtorrent
{
if (info[j].peer)
{
torrent_peer* p = static_cast<torrent_peer*>(info[j].peer);
torrent_peer* p = info[j].peer;
TORRENT_ASSERT(p->in_use);
TORRENT_ASSERT(p->connection == NULL
|| static_cast<peer_connection*>(p->connection)->m_in_use);
@ -435,7 +435,7 @@ namespace libtorrent
#if TORRENT_USE_INVARIANT_CHECKS
void piece_picker::check_peer_invariant(bitfield const& have
, void const* p) const
, torrent_peer const* p) const
{
#ifdef TORRENT_DEBUG_REFCOUNTS
int num_pieces = have.size();
@ -482,7 +482,7 @@ namespace libtorrent
for (int j = 0; j < m_blocks_per_piece; ++j)
{
if (!info[j].peer) continue;
torrent_peer* p = static_cast<torrent_peer*>(info[j].peer);
torrent_peer* p = info[j].peer;
TORRENT_ASSERT(p->in_use);
TORRENT_ASSERT(p->connection == NULL
|| static_cast<peer_connection*>(p->connection)->m_in_use);
@ -511,7 +511,7 @@ namespace libtorrent
{
TORRENT_ASSERT(info[k].piece_index == i->index);
TORRENT_ASSERT(info[k].peer == 0
|| static_cast<torrent_peer*>(info[k].peer)->in_use);
|| info[k].peer->in_use);
if (info[k].state == block_info::state_finished)
{
@ -1136,7 +1136,7 @@ namespace libtorrent
#endif
}
void piece_picker::inc_refcount_all(const void* peer)
void piece_picker::inc_refcount_all(const torrent_peer* peer)
{
#ifdef TORRENT_EXPENSIVE_INVARIANT_CHECKS
TORRENT_PIECE_PICKER_INVARIANT_CHECK;
@ -1162,7 +1162,7 @@ namespace libtorrent
#endif
}
void piece_picker::dec_refcount_all(const void* peer)
void piece_picker::dec_refcount_all(const torrent_peer* peer)
{
#ifdef TORRENT_EXPENSIVE_INVARIANT_CHECKS
TORRENT_PIECE_PICKER_INVARIANT_CHECK;
@ -1209,7 +1209,7 @@ namespace libtorrent
m_dirty = true;
}
void piece_picker::inc_refcount(int index, const void* peer)
void piece_picker::inc_refcount(int index, const torrent_peer* peer)
{
#ifdef TORRENT_EXPENSIVE_INVARIANT_CHECKS
TORRENT_PIECE_PICKER_INVARIANT_CHECK;
@ -1260,7 +1260,7 @@ namespace libtorrent
m_dirty = true;
}
void piece_picker::dec_refcount(int index, const void* peer)
void piece_picker::dec_refcount(int index, const torrent_peer* peer)
{
#ifdef TORRENT_EXPENSIVE_INVARIANT_CHECKS
TORRENT_PIECE_PICKER_INVARIANT_CHECK;
@ -1297,7 +1297,7 @@ namespace libtorrent
if (prev_priority >= 0) update(prev_priority, p.index);
}
void piece_picker::inc_refcount(bitfield const& bitmask, const void* peer)
void piece_picker::inc_refcount(bitfield const& bitmask, const torrent_peer* peer)
{
#ifdef TORRENT_EXPENSIVE_INVARIANT_CHECKS
TORRENT_PIECE_PICKER_INVARIANT_CHECK;
@ -1393,7 +1393,7 @@ namespace libtorrent
if (updated) m_dirty = true;
}
void piece_picker::dec_refcount(bitfield const& bitmask, const void* peer)
void piece_picker::dec_refcount(bitfield const& bitmask, const torrent_peer* peer)
{
#ifdef TORRENT_EXPENSIVE_INVARIANT_CHECKS
TORRENT_PIECE_PICKER_INVARIANT_CHECK;
@ -1935,7 +1935,7 @@ namespace libtorrent
// num_blocks of interesting blocks that the peer has.
// prefer_contiguous_blocks can be set if this peer should download whole
// pieces rather than trying to download blocks from the same piece as other
// peers. the void* is the pointer to the torrent_peer of the peer we're
// peers. the peer argument is the torrent_peer of the peer we're
// picking pieces from. This is used when downloading whole pieces, to only
// pick from the same piece the same peer is downloading from.
@ -1958,13 +1958,13 @@ namespace libtorrent
void piece_picker::pick_pieces(bitfield const& pieces
, std::vector<piece_block>& interesting_blocks, int num_blocks
, int prefer_contiguous_blocks, void* peer
, int prefer_contiguous_blocks, torrent_peer* peer
, int options, std::vector<int> const& suggested_pieces
, int num_peers
, counters& pc
) const
{
TORRENT_ASSERT(peer == 0 || static_cast<torrent_peer*>(peer)->in_use);
TORRENT_ASSERT(peer == 0 || peer->in_use);
// prevent the number of partial pieces to grow indefinitely
// make this scale by the number of peers we have. For large
@ -2571,7 +2571,7 @@ get_out:
}
#endif
void piece_picker::clear_peer(void* peer)
void piece_picker::clear_peer(torrent_peer* peer)
{
for (std::vector<block_info>::iterator i = m_block_info.begin()
, end(m_block_info.end()); i != end; ++i)
@ -2588,7 +2588,7 @@ get_out:
// the first-fit range, which would be better
boost::tuple<bool, bool, int, int> piece_picker::requested_from(
piece_picker::downloading_piece const& p
, int num_blocks_in_piece, void* peer) const
, int num_blocks_in_piece, torrent_peer* peer) const
{
bool exclusive = true;
bool exclusive_active = true;
@ -2637,7 +2637,7 @@ get_out:
, std::vector<piece_block>& backup_blocks
, std::vector<piece_block>& backup_blocks2
, int num_blocks, int prefer_contiguous_blocks
, void* peer, std::vector<int> const& ignore
, torrent_peer* peer, std::vector<int> const& ignore
, int options) const
{
TORRENT_ASSERT(piece >= 0);
@ -2717,7 +2717,7 @@ get_out:
, std::vector<piece_block>& backup_blocks
, std::vector<piece_block>& backup_blocks2
, int num_blocks, int prefer_contiguous_blocks
, void* peer, int options) const
, torrent_peer* peer, int options) const
{
if (!pieces[dp.index]) return num_blocks;
TORRENT_ASSERT(!m_piece_map[dp.index].filtered());
@ -3101,7 +3101,7 @@ get_out:
// options may be 0 or piece_picker::reverse
bool piece_picker::mark_as_downloading(piece_block block
, void* peer, int options)
, torrent_peer* peer, int options)
{
#ifdef TORRENT_PICKER_LOG
std::cerr << "[" << this << "] " << "mark_as_downloading( {"
@ -3245,7 +3245,7 @@ get_out:
return m_piece_map[piece].peer_count + m_seeds;
}
bool piece_picker::mark_as_writing(piece_block block, void* peer)
bool piece_picker::mark_as_writing(piece_block block, torrent_peer* peer)
{
#ifdef TORRENT_EXPENSIVE_INVARIANT_CHECKS
TORRENT_PIECE_PICKER_INVARIANT_CHECK;
@ -3437,7 +3437,7 @@ get_out:
}
}
void piece_picker::mark_as_canceled(const piece_block block, void* peer)
void piece_picker::mark_as_canceled(const piece_block block, torrent_peer* peer)
{
#ifdef TORRENT_PICKER_LOG
std::cerr << "[" << this << "] " << "mark_as_cancelled( {"
@ -3501,7 +3501,7 @@ get_out:
#endif
}
void piece_picker::mark_as_finished(piece_block block, void* peer)
void piece_picker::mark_as_finished(piece_block block, torrent_peer* peer)
{
#if TORRENT_USE_INVARIANT_CHECKS
check_piece_state();
@ -3622,7 +3622,7 @@ get_out:
}
*/
void piece_picker::get_downloaders(std::vector<void*>& d, int index) const
void piece_picker::get_downloaders(std::vector<torrent_peer*>& d, int index) const
{
TORRENT_ASSERT(index >= 0 && index <= int(m_piece_map.size()));
@ -3633,7 +3633,7 @@ get_out:
if (state == piece_pos::piece_open)
{
for (int i = 0; i < num_blocks; ++i) d.push_back(0);
for (int i = 0; i < num_blocks; ++i) d.push_back(NULL);
return;
}
@ -3644,12 +3644,12 @@ get_out:
for (int j = 0; j != num_blocks; ++j)
{
TORRENT_ASSERT(binfo[j].peer == 0
|| static_cast<torrent_peer*>(binfo[j].peer)->in_use);
|| binfo[j].peer->in_use);
d.push_back(binfo[j].peer);
}
}
void* piece_picker::get_downloader(piece_block block) const
torrent_peer* piece_picker::get_downloader(piece_block block) const
{
int state = m_piece_map[block.piece_index].download_queue();
if (state == piece_pos::piece_open) return 0;
@ -3661,16 +3661,16 @@ get_out:
block_info const* binfo = blocks_for_piece(*i);
TORRENT_ASSERT(binfo[block.block_index].piece_index == block.piece_index);
if (binfo[block.block_index].state == block_info::state_none)
return 0;
return NULL;
void* peer = binfo[block.block_index].peer;
torrent_peer* peer = binfo[block.block_index].peer;
TORRENT_ASSERT(peer == 0 || static_cast<torrent_peer*>(peer)->in_use);
return peer;
}
// this is called when a request is rejected or when
// a peer disconnects. The piece might be in any state
void piece_picker::abort_download(piece_block block, void* peer)
void piece_picker::abort_download(piece_block block, torrent_peer* peer)
{
#ifdef TORRENT_EXPENSIVE_INVARIANT_CHECKS
TORRENT_PIECE_PICKER_INVARIANT_CHECK;
@ -3679,7 +3679,7 @@ get_out:
#ifdef TORRENT_PICKER_LOG
std::cerr << "[" << this << "] " << "abort_download( {" << block.piece_index << ", " << block.block_index << "} )" << std::endl;
#endif
TORRENT_ASSERT(peer == 0 || static_cast<torrent_peer*>(peer)->in_use);
TORRENT_ASSERT(peer == 0 || peer->in_use);
TORRENT_ASSERT(block.block_index != piece_block::invalid.block_index);
TORRENT_ASSERT(block.piece_index != piece_block::invalid.piece_index);
@ -3695,7 +3695,7 @@ get_out:
block_info* binfo = blocks_for_piece(*i);
block_info& info = binfo[block.block_index];
TORRENT_ASSERT(info.peer == 0 || static_cast<torrent_peer*>(info.peer)->in_use);
TORRENT_ASSERT(info.peer == 0 || info.peer->in_use);
TORRENT_ASSERT(info.piece_index == block.piece_index);
TORRENT_ASSERT(info.state != block_info::state_none);

10
src/smart_ban.cpp
View File

@ -195,16 +195,16 @@ namespace
// a bunch of read operations on it
if (m_torrent.is_aborted()) return;
std::vector<void*> downloaders;
std::vector<torrent_peer*> downloaders;
m_torrent.picker().get_downloaders(downloaders, p);
int size = m_torrent.torrent_file().piece_size(p);
peer_request r = {p, 0, (std::min)(16*1024, size)};
piece_block pb(p, 0);
for (std::vector<void*>::iterator i = downloaders.begin()
for (std::vector<torrent_peer*>::iterator i = downloaders.begin()
, end(downloaders.end()); i != end; ++i)
{
if (*i != 0)
if (*i != NULL)
{
// for very sad and involved reasons, this read need to force a copy out of the cache
// since the piece has failed, this block is very likely to be replaced with a newly
@ -212,8 +212,8 @@ namespace
// block read will have been deleted by the time it gets back to the network thread
m_torrent.session().disk_thread().async_read(&m_torrent.storage(), r
, boost::bind(&smart_ban_plugin::on_read_failed_block
, shared_from_this(), pb, static_cast<torrent_peer*>(*i)->address(), _1)
, reinterpret_cast<void*>(1)
, shared_from_this(), pb, (*i)->address(), _1)
, reinterpret_cast<torrent_peer*>(1)
, disk_io_job::force_copy);
}

49
src/torrent.cpp
View File

@ -4250,12 +4250,12 @@ namespace libtorrent
remove_time_critical_piece(index, true);
std::vector<void*> downloaders;
std::vector<torrent_peer*> downloaders;
m_picker->get_downloaders(downloaders, index);
// increase the trust point of all peers that sent
// parts of this piece.
std::set<void*> peers;
std::set<torrent_peer*> peers;
// these torrent_peer pointers are owned by m_peer_list and they may be
// invalidated if a peer disconnects. We cannot keep them across any
@ -4264,7 +4264,7 @@ namespace libtorrent
std::remove_copy(downloaders.begin(), downloaders.end()
, std::inserter(peers, peers.begin()), static_cast<torrent_peer*>(0));
for (std::set<void*>::iterator i = peers.begin()
for (std::set<torrent_peer*>::iterator i = peers.begin()
, end(peers.end()); i != end; ++i)
{
torrent_peer* p = static_cast<torrent_peer*>(*i);
@ -4368,18 +4368,18 @@ namespace libtorrent
}
#endif
std::vector<void*> downloaders;
std::vector<torrent_peer*> downloaders;
if (m_picker)
m_picker->get_downloaders(downloaders, index);
// decrease the trust point of all peers that sent
// parts of this piece.
// first, build a set of all peers that participated
std::set<void*> peers;
std::set<torrent_peer*> peers;
std::copy(downloaders.begin(), downloaders.end(), std::inserter(peers, peers.begin()));
#ifdef TORRENT_DEBUG
for (std::vector<void*>::iterator i = downloaders.begin()
for (std::vector<torrent_peer*>::iterator i = downloaders.begin()
, end(downloaders.end()); i != end; ++i)
{
torrent_peer* p = static_cast<torrent_peer*>(*i);
@ -4394,7 +4394,7 @@ namespace libtorrent
// did we receive this piece from a single peer?
bool single_peer = peers.size() == 1;
for (std::set<void*>::iterator i = peers.begin()
for (std::set<torrent_peer*>::iterator i = peers.begin()
, end(peers.end()); i != end; ++i)
{
torrent_peer* p = static_cast<torrent_peer*>(*i);
@ -4497,7 +4497,7 @@ namespace libtorrent
}
#ifdef TORRENT_DEBUG
for (std::vector<void*>::iterator i = downloaders.begin()
for (std::vector<torrent_peer*>::iterator i = downloaders.begin()
, end(downloaders.end()); i != end; ++i)
{
torrent_peer* p = (torrent_peer*)*i;
@ -4573,7 +4573,8 @@ namespace libtorrent
{
if (has_picker())
{
m_picker->inc_refcount(index, peer);
torrent_peer* pp = peer->peer_info_struct();
m_picker->inc_refcount(index, pp);
update_suggest_piece(index, 1);
}
#ifdef TORRENT_DEBUG
@ -4589,7 +4590,8 @@ namespace libtorrent
{
if (has_picker())
{
m_picker->inc_refcount(bits, peer);
torrent_peer* pp = peer->peer_info_struct();
m_picker->inc_refcount(bits, pp);
refresh_suggest_pieces();
}
#ifdef TORRENT_DEBUG
@ -4604,7 +4606,8 @@ namespace libtorrent
{
if (has_picker())
{
m_picker->inc_refcount_all(peer);
torrent_peer* pp = peer->peer_info_struct();
m_picker->inc_refcount_all(pp);
}
#ifdef TORRENT_DEBUG
else
@ -4618,7 +4621,8 @@ namespace libtorrent
{
if (has_picker())
{
m_picker->dec_refcount(bits, peer);
torrent_peer* pp = peer->peer_info_struct();
m_picker->dec_refcount(bits, pp);
// TODO: update suggest_piece?
}
#ifdef TORRENT_DEBUG
@ -4633,7 +4637,8 @@ namespace libtorrent
{
if (m_picker.get())
{
m_picker->dec_refcount(index, peer);
torrent_peer* pp = peer->peer_info_struct();
m_picker->dec_refcount(index, pp);
update_suggest_piece(index, -1);
}
#ifdef TORRENT_DEBUG
@ -5127,14 +5132,14 @@ namespace libtorrent
// this means we have outstanding requests (or queued
// up requests that haven't been sent yet). Promote them
// to deadline pieces immediately
std::vector<void*> downloaders;
std::vector<torrent_peer*> downloaders;
m_picker->get_downloaders(downloaders, piece);
int block = 0;
for (std::vector<void*>::iterator i = downloaders.begin()
for (std::vector<torrent_peer*>::iterator i = downloaders.begin()
, end(downloaders.end()); i != end; ++i, ++block)
{
torrent_peer* p = static_cast<torrent_peer*>(*i);
torrent_peer* p = *i;
if (p == 0 || p->connection == 0) continue;
peer_connection* peer = static_cast<peer_connection*>(p->connection);
peer->make_time_critical(piece_block(piece, block));
@ -5944,6 +5949,7 @@ namespace libtorrent
return;
}
torrent_peer* pp = p->peer_info_struct();
if (ready_for_connections())
{
TORRENT_ASSERT(p->associated_torrent().lock().get() == NULL
@ -5953,7 +5959,7 @@ namespace libtorrent
{
if (has_picker())
{
m_picker->dec_refcount_all(p);
m_picker->dec_refcount_all(pp);
}
}
else
@ -5962,7 +5968,7 @@ namespace libtorrent
{
bitfield const& pieces = p->get_bitfield();
TORRENT_ASSERT(pieces.count() <= int(pieces.size()));
m_picker->dec_refcount(pieces, p);
m_picker->dec_refcount(pieces, pp);
}
}
}
@ -5973,7 +5979,6 @@ namespace libtorrent
trigger_unchoke();
}
torrent_peer* pp = p->peer_info_struct();
if (pp)
{
if (pp->optimistically_unchoked)
@ -11190,7 +11195,7 @@ namespace libtorrent
inc_refcount("verify_piece");
m_ses.disk_thread().async_hash(m_storage.get(), piece, 0
, boost::bind(&torrent::on_piece_verified, shared_from_this(), _1)
, (void*)1);
, reinterpret_cast<void*>(1));
}
announce_entry* torrent::find_tracker(tracker_request const& r)
@ -11210,7 +11215,7 @@ namespace libtorrent
torrent_state st = get_peer_list_state();
std::vector<address> banned;
m_peer_list->apply_ip_filter(*m_ip_filter, &st, banned);
if (alerts().should_post<peer_blocked_alert>())
{
for (std::vector<address>::iterator i = banned.begin()
@ -11218,7 +11223,7 @@ namespace libtorrent
alerts().emplace_alert<peer_blocked_alert>(get_handle(), *i
, peer_blocked_alert::ip_filter);
}
peers_erased(st.erased);
}

36
test/test_piece_picker.cpp
View File

@ -124,16 +124,16 @@ boost::shared_ptr<piece_picker> setup_picker(
TEST_CHECK(!p->is_finished(piece_block(i, j)));
if ((blocks & (1 << j)) == 0) continue;
++counter;
bool ret = p->mark_as_downloading(piece_block(i, j), (void*)tmp_peer);
bool ret = p->mark_as_downloading(piece_block(i, j), tmp_peer);
TEST_CHECK(ret == true);
TEST_CHECK(p->is_requested(piece_block(i, j)) == bool(blocks & (1 << j)));
p->mark_as_writing(piece_block(i, j), (void*)tmp_peer);
p->mark_as_writing(piece_block(i, j), tmp_peer);
TEST_CHECK(!p->is_finished(piece_block(i, j)));
// trying to mark a block as requested after it has been completed
// should fail (return false)
ret = p->mark_as_downloading(piece_block(i, j), (void*)tmp_peer);
ret = p->mark_as_downloading(piece_block(i, j), tmp_peer);
TEST_CHECK(ret == false);
p->mark_as_finished(piece_block(i, j), (void*)tmp_peer);
p->mark_as_finished(piece_block(i, j), tmp_peer);
TEST_CHECK(p->is_downloaded(piece_block(i, j)) == bool(blocks & (1 << j)));
TEST_CHECK(p->is_finished(piece_block(i, j)) == bool(blocks & (1 << j)));
@ -250,7 +250,7 @@ std::vector<piece_block> pick_pieces(boost::shared_ptr<piece_picker> const& p
, char const* availability
, int num_blocks
, int prefer_contiguous_blocks
, void* peer_struct
, torrent_peer* peer_struct
, int options = piece_picker::rarest_first
, std::vector<int> const& suggested_pieces = empty_vector)
{
@ -408,7 +408,7 @@ TORRENT_TEST(piece_picker)
p->mark_as_downloading(piece_block(0, 2), &tmp2);
p->mark_as_writing(piece_block(0, 2), &tmp2);
std::vector<void*> d;
std::vector<torrent_peer*> d;
p->get_downloaders(d, 0);
TEST_EQUAL(d.size(), 4);
TEST_CHECK(d[0] == NULL);
@ -1166,12 +1166,12 @@ TORRENT_TEST(piece_picker)
p->mark_as_downloading(piece_block(2, 1), &tmp2);
p->mark_as_downloading(piece_block(3, 1), &tmp3);
std::vector<void*> dls;
void* expected_dls1[] = {&tmp1, &tmp2, &tmp3, 0};
void* expected_dls2[] = {0, &tmp1, 0, 0};
void* expected_dls3[] = {0, &tmp2, 0, 0};
void* expected_dls4[] = {0, &tmp3, 0, 0};
void* expected_dls5[] = {&tmp1, 0, &tmp3, 0};
std::vector<torrent_peer*> dls;
torrent_peer* expected_dls1[] = {&tmp1, &tmp2, &tmp3, 0};
torrent_peer* expected_dls2[] = {0, &tmp1, 0, 0};
torrent_peer* expected_dls3[] = {0, &tmp2, 0, 0};
torrent_peer* expected_dls4[] = {0, &tmp3, 0, 0};
torrent_peer* expected_dls5[] = {&tmp1, 0, &tmp3, 0};
p->get_downloaders(dls, 0);
TEST_CHECK(std::equal(dls.begin(), dls.end(), expected_dls1));
p->get_downloaders(dls, 1);
@ -1238,7 +1238,7 @@ TORRENT_TEST(piece_picker)
// decrease refcount on something that's not in the piece list
p->dec_refcount(5, &tmp0);
p->inc_refcount(5, &tmp0);
bitfield bits = string2vec("* ");
TEST_EQUAL(bits.get_bit(0), true);
TEST_EQUAL(bits.get_bit(1), false);
@ -1261,14 +1261,14 @@ TORRENT_TEST(piece_picker)
TEST_EQUAL(test_pick(p), 0);
// ========================================================
// test unverified_blocks, marking blocks and get_downloader
print_title("test unverified blocks");
p = setup_picker("1111111", " ", "", "0300700");
TEST_CHECK(p->unverified_blocks() == 2 + 3);
TEST_CHECK(p->get_downloader(piece_block(4, 0)) == (void*)tmp_peer);
TEST_CHECK(p->get_downloader(piece_block(4, 1)) == (void*)tmp_peer);
TEST_CHECK(p->get_downloader(piece_block(4, 2)) == (void*)tmp_peer);
TEST_CHECK(p->get_downloader(piece_block(4, 0)) == tmp_peer);
TEST_CHECK(p->get_downloader(piece_block(4, 1)) == tmp_peer);
TEST_CHECK(p->get_downloader(piece_block(4, 2)) == tmp_peer);
TEST_CHECK(p->get_downloader(piece_block(4, 3)) == 0);
p->mark_as_downloading(piece_block(4, 3), &peer_struct);
TEST_CHECK(p->get_downloader(piece_block(4, 3)) == &peer_struct);
@ -1300,7 +1300,7 @@ TORRENT_TEST(piece_picker)
TEST_CHECK(p->unverified_blocks() == 2);
// ========================================================
// test prefer_contiguous_blocks
print_title("test prefer contiguous blocks");
p = setup_picker("1111111", " ", "", "");