This class creates sha1-hashes. Its declaration looks like this:
diff --git a/docs/manual.rst b/docs/manual.rst
index 0c4ee3660..9b9b3af52 100644
--- a/docs/manual.rst
+++ b/docs/manual.rst
@@ -2197,7 +2197,7 @@ It contains the following fields::
int connect_candidates;
- const std::vector* pieces;
+ bitfield pieces;
int num_pieces;
size_type total_done;
@@ -2466,7 +2466,7 @@ It contains the following fields::
size_type total_download;
size_type total_upload;
peer_id pid;
- std::vector pieces;
+ bitfield pieces;
int upload_limit;
int download_limit;
@@ -2642,9 +2642,9 @@ the payload data.
extract 'fingerprints' from the peer. Sometimes it can tell you which client the peer
is using. See identify_client()_
-``pieces`` is a vector of booleans that has as many entries as there are pieces
-in the torrent. Each boolean tells you if the peer has that piece (if it's set to true)
-or if the peer miss that piece (set to false).
+``pieces`` is a bitfield, with one bit per piece in the torrent.
+Each bit tells you if the peer has that piece (if it's set to 1)
+or if the peer miss that piece (set to 0).
``seed`` is true if this peer is a seed.
@@ -3291,6 +3291,53 @@ Both the ``peer_id`` and ``sha1_hash`` types are typedefs of the class
The iterators gives you access to individual bytes.
+bitfield
+========
+
+The bitfiled type stores any number of bits as a bitfield in an array.
+
+::
+
+ class bitfield
+ {
+ bitfield();
+ bitfield(int bits);
+ bitfield(int bits, bool val);
+ bitfield(char const* bytes, int bits);
+ bitfield(bitfield const& rhs);
+
+ void borrow_bytes(char* bytes, int bits);
+ ~bitfield();
+
+ void assign(char const* bytes, int bits);
+
+ bool operator[](int index) const;
+
+ bool get_bit(int index) const;
+
+ void clear_bit(int index);
+ void set_bit(int index);
+
+ std::size_t size() const;
+ bool empty() const;
+
+ char const* bytes() const;
+
+ bitfield& operator=(bitfield const& rhs);
+
+ int count() const;
+
+ typedef const_iterator;
+ const_iterator begin() const;
+ const_iterator end() const;
+
+ void resize(int bits, bool val);
+ void set_all();
+ void clear_all();
+ void resize(int bits);
+ };
+
+
hasher
======
diff --git a/examples/client_test.cpp b/examples/client_test.cpp
index 43f2f401e..9b87cbc36 100644
--- a/examples/client_test.cpp
+++ b/examples/client_test.cpp
@@ -1317,8 +1317,8 @@ int main(int ac, char* av[])
out.fill(' ');
out << (s.progress*100) << "% ";
out << progress_bar(s.progress, terminal_width - 37, progress_bar_color) << "\n";
- if (print_piece_bar && s.progress < 1.f && s.pieces)
- out << " " << piece_bar(*s.pieces, terminal_width - 5) << "\n";
+ if (print_piece_bar && s.progress < 1.f)
+ out << " " << piece_bar(s.pieces, terminal_width - 5) << "\n";
out << " peers: " << esc("37") << s.num_peers << esc("0") << " (" << esc("37") << s.connect_candidates << esc("0") << ") "
<< "seeds: " << esc("37") << s.num_seeds << esc("0") << " "
<< "distributed copies: " << esc("37") << s.distributed_copies << esc("0")
diff --git a/include/libtorrent/bt_peer_connection.hpp b/include/libtorrent/bt_peer_connection.hpp
index 370bd3ab8..09b665b4a 100755
--- a/include/libtorrent/bt_peer_connection.hpp
+++ b/include/libtorrent/bt_peer_connection.hpp
@@ -209,7 +209,7 @@ namespace libtorrent
void write_not_interested();
void write_request(peer_request const& r);
void write_cancel(peer_request const& r);
- void write_bitfield(bitfield const& bits);
+ void write_bitfield();
void write_have(int index);
void write_piece(peer_request const& r, disk_buffer_holder& buffer);
void write_handshake();
diff --git a/include/libtorrent/piece_picker.hpp b/include/libtorrent/piece_picker.hpp
index 6be92ffa1..4b9e6bcc5 100755
--- a/include/libtorrent/piece_picker.hpp
+++ b/include/libtorrent/piece_picker.hpp
@@ -129,18 +129,13 @@ namespace libtorrent
boost::int16_t requested;
};
- piece_picker(int blocks_per_piece
- , int total_num_blocks);
+ piece_picker();
void get_availability(std::vector& avail) const;
void sequential_download(bool sd);
bool sequential_download() const { return m_sequential_download >= 0; }
- // the vector tells which pieces we already have
- // and which we don't have.
- void init(bitfield const& pieces);
-
// increases the peer count for the given piece
// (is used when a HAVE message is received)
void inc_refcount(int index);
@@ -164,6 +159,17 @@ namespace libtorrent
// we are not interested in this piece anymore
// (i.e. we don't have to maintain a refcount)
void we_have(int index);
+ void we_dont_have(int index);
+
+ void init(int blocks_per_piece, int total_num_blocks);
+ int num_pieces() const { return int(m_piece_map.size()); }
+
+ bool have_piece(int index) const
+ {
+ TORRENT_ASSERT(index >= 0);
+ TORRENT_ASSERT(index < int(m_piece_map.size()));
+ return m_piece_map[index].index == piece_pos::we_have_index;
+ }
// sets the priority of a piece.
// returns true if the priority was changed from 0 to non-0
@@ -276,6 +282,8 @@ namespace libtorrent
// the number of filtered pieces we already have
int num_have_filtered() const { return m_num_have_filtered; }
+ int num_have() const { return m_num_have; }
+
#ifndef NDEBUG
// used in debug mode
void verify_priority(int start, int end, int prio) const;
@@ -350,6 +358,7 @@ namespace libtorrent
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 filtered() const { return piece_priority == filter_priority; }
void filtered(bool f) { piece_priority = f ? filter_priority : 0; }
@@ -466,10 +475,6 @@ namespace libtorrent
// if this is set to true, it means update_pieces()
// has to be called before accessing m_pieces.
mutable bool m_dirty;
-
-#ifndef NDEBUG
- bool m_files_checked_called;
-#endif
};
inline int piece_picker::blocks_in_piece(int index) const
diff --git a/include/libtorrent/torrent.hpp b/include/libtorrent/torrent.hpp
index 1cae939a3..20946c884 100755
--- a/include/libtorrent/torrent.hpp
+++ b/include/libtorrent/torrent.hpp
@@ -378,14 +378,15 @@ namespace libtorrent
// returns true if we have downloaded the given piece
bool have_piece(int index) const
{
- TORRENT_ASSERT(index >= 0 && index < (signed)m_have_pieces.size());
- return m_have_pieces[index];
+ return has_picker()?m_picker->have_piece(index):true;
}
- bitfield const& pieces() const
- { return m_have_pieces; }
-
- int num_pieces() const { return m_num_pieces; }
+ int num_pieces() const
+ {
+ return has_picker()
+ ?m_picker->num_have()
+ :m_torrent_file->num_pieces();
+ }
// when we get a have message, this is called for that piece
void peer_has(int index)
@@ -393,7 +394,6 @@ namespace libtorrent
if (m_picker.get())
{
TORRENT_ASSERT(!is_seed());
- TORRENT_ASSERT(index >= 0 && index < (signed)m_have_pieces.size());
m_picker->inc_refcount(index);
}
#ifndef NDEBUG
@@ -440,7 +440,6 @@ namespace libtorrent
if (m_picker.get())
{
TORRENT_ASSERT(!is_seed());
- TORRENT_ASSERT(index >= 0 && index < (signed)m_have_pieces.size());
m_picker->dec_refcount(index);
}
#ifndef NDEBUG
@@ -507,7 +506,9 @@ namespace libtorrent
bool is_seed() const
{
return valid_metadata()
- && m_num_pieces == m_torrent_file->num_pieces();
+ && (!m_picker
+ || m_state == torrent_status::seeding
+ || m_picker->num_have() == m_picker->num_pieces());
}
// this is true if we have all the pieces that we want
@@ -515,7 +516,7 @@ namespace libtorrent
{
if (is_seed()) return true;
return valid_metadata() && m_torrent_file->num_pieces()
- - m_num_pieces - m_picker->num_filtered() == 0;
+ - m_picker->num_have() - m_picker->num_filtered() == 0;
}
fs::path save_path() const;
@@ -741,9 +742,6 @@ namespace libtorrent
std::vector m_trackers;
// this is an index into m_trackers
- // the bitmask that says which pieces we have
- bitfield m_have_pieces;
-
// the number of bytes that has been
// downloaded that failed the hash-test
size_type m_total_failed_bytes;
@@ -782,11 +780,6 @@ namespace libtorrent
float m_progress;
- // the number of pieces we have. The same as
- // std::accumulate(m_have_pieces.begin(),
- // m_have_pieces.end(), 0)
- int m_num_pieces;
-
// the upload/download ratio that each peer
// tries to maintain.
// 0 is infinite
diff --git a/include/libtorrent/torrent_handle.hpp b/include/libtorrent/torrent_handle.hpp
index 3d511d931..9f21b099d 100755
--- a/include/libtorrent/torrent_handle.hpp
+++ b/include/libtorrent/torrent_handle.hpp
@@ -100,7 +100,6 @@ namespace libtorrent
, num_incomplete(-1)
, list_seeds(0)
, list_peers(0)
- , pieces(0)
, num_pieces(0)
, total_done(0)
, total_wanted_done(0)
@@ -201,7 +200,7 @@ namespace libtorrent
// we potentially could connect to
int connect_candidates;
- bitfield const* pieces;
+ bitfield pieces;
// this is the number of pieces the client has
// downloaded. it is equal to:
diff --git a/src/bt_peer_connection.cpp b/src/bt_peer_connection.cpp
index eeb40e478..b81daf9f4 100755
--- a/src/bt_peer_connection.cpp
+++ b/src/bt_peer_connection.cpp
@@ -245,7 +245,7 @@ namespace libtorrent
{
boost::shared_ptr t = associated_torrent().lock();
TORRENT_ASSERT(t);
- write_bitfield(t->pieces());
+ write_bitfield();
#ifndef TORRENT_DISABLE_DHT
if (m_supports_dht_port && m_ses.m_dht)
write_dht_port(m_ses.get_dht_settings().service_port);
@@ -1416,7 +1416,7 @@ namespace libtorrent
send_buffer(msg, sizeof(msg));
}
- void bt_peer_connection::write_bitfield(bitfield const& bits)
+ void bt_peer_connection::write_bitfield()
{
INVARIANT_CHECK;
@@ -1449,14 +1449,11 @@ namespace libtorrent
return;
}
- int num_pieces = bits.size();
+ int num_pieces = t->picker().num_pieces();
int lazy_pieces[50];
int num_lazy_pieces = 0;
int lazy_piece = 0;
- TORRENT_ASSERT(t->is_seed() == (bits.count()
- == num_pieces));
-
if (t->is_seed() && m_ses.settings().lazy_bitfields)
{
num_lazy_pieces = (std::min)(50, num_pieces / 10);
@@ -1470,26 +1467,6 @@ namespace libtorrent
lazy_piece = 0;
}
-#ifdef TORRENT_VERBOSE_LOGGING
- (*m_logger) << time_now_string() << " ==> BITFIELD ";
-
- std::stringstream bitfield_string;
- for (int i = 0; i < (int)get_bitfield().size(); ++i)
- {
- if (lazy_piece < num_lazy_pieces
- && lazy_pieces[lazy_piece] == i)
- {
- bitfield_string << "0";
- ++lazy_piece;
- continue;
- }
- if (bits[i]) bitfield_string << "1";
- else bitfield_string << "0";
- }
- bitfield_string << "\n";
- (*m_logger) << bitfield_string.str();
- lazy_piece = 0;
-#endif
const int packet_size = (num_pieces + 7) / 8 + 5;
buffer::interval i = allocate_send_buffer(packet_size);
@@ -1498,15 +1475,46 @@ namespace libtorrent
detail::write_int32(packet_size - 4, i.begin);
detail::write_uint8(msg_bitfield, i.begin);
- memcpy(i.begin, bits.bytes(), packet_size - 5);
+ if (t->is_seed())
+ {
+ memset(i.begin, 0xff, packet_size - 5);
+ }
+ else
+ {
+ memset(i.begin, 0, packet_size - 5);
+ piece_picker const& p = t->picker();
+ int mask = 0x80;
+ unsigned char* byte = (unsigned char*)i.begin;
+ for (int i = 0; i < num_pieces; ++i)
+ {
+ if (p.have_piece(i)) *byte |= mask;
+ mask >>= 1;
+ if (mask == 0)
+ {
+ mask = 0x80;
+ ++byte;
+ }
+ }
+ }
for (int c = 0; c < num_lazy_pieces; ++c)
i.begin[lazy_pieces[c] / 8] &= ~(0x80 >> (lazy_pieces[c] & 7));
TORRENT_ASSERT(i.end - i.begin == (num_pieces + 7) / 8);
+#ifdef TORRENT_VERBOSE_LOGGING
+ (*m_logger) << time_now_string() << " ==> BITFIELD ";
+
+ std::stringstream bitfield_string;
+ for (int k = 0; k < num_pieces; ++k)
+ {
+ if (i.begin[k / 8] & (0x80 >> (k % 8))) bitfield_string << "1";
+ else bitfield_string << "0";
+ }
+ bitfield_string << "\n";
+ (*m_logger) << bitfield_string.str();
+#endif
#ifndef NDEBUG
m_sent_bitfield = true;
#endif
- setup_send();
if (num_lazy_pieces > 0)
{
@@ -1522,6 +1530,7 @@ namespace libtorrent
if (m_supports_fast)
send_allowed_set();
+ setup_send();
}
#ifndef TORRENT_DISABLE_EXTENSIONS
@@ -2377,7 +2386,7 @@ namespace libtorrent
// sent the handshake
if (!is_local()) write_handshake();
// if (t->valid_metadata())
-// write_bitfield(t->pieces());
+// write_bitfield();
if (is_disconnecting()) return;
@@ -2511,7 +2520,7 @@ namespace libtorrent
reset_recv_buffer(5);
if (t->valid_metadata())
{
- write_bitfield(t->pieces());
+ write_bitfield();
#ifndef TORRENT_DISABLE_DHT
if (m_supports_dht_port && m_ses.m_dht)
write_dht_port(m_ses.get_dht_settings().service_port);
diff --git a/src/peer_connection.cpp b/src/peer_connection.cpp
index 29adfcfe2..f01193b96 100755
--- a/src/peer_connection.cpp
+++ b/src/peer_connection.cpp
@@ -326,15 +326,19 @@ namespace libtorrent
TORRENT_ASSERT(t);
bool interested = false;
- bitfield const& we_have = t->pieces();
- for (int j = 0; j != (int)we_have.size(); ++j)
+ if (!t->is_finished())
{
- if (!we_have[j]
- && t->piece_priority(j) > 0
- && m_have_piece[j])
+ piece_picker const& p = t->picker();
+ int num_pieces = p.num_pieces();
+ for (int j = 0; j != num_pieces; ++j)
{
- interested = true;
- break;
+ if (!p.have_piece(j)
+ && t->piece_priority(j) > 0
+ && m_have_piece[j])
+ {
+ interested = true;
+ break;
+ }
}
}
try
diff --git a/src/piece_picker.cpp b/src/piece_picker.cpp
index 0b75b425e..f0b7fb937 100755
--- a/src/piece_picker.cpp
+++ b/src/piece_picker.cpp
@@ -58,10 +58,9 @@ POSSIBILITY OF SUCH DAMAGE.
namespace libtorrent
{
- piece_picker::piece_picker(int blocks_per_piece, int total_num_blocks)
+ piece_picker::piece_picker()
: m_seeds(0)
, m_priority_boundries(1, int(m_pieces.size()))
- , m_piece_map((total_num_blocks + blocks_per_piece-1) / blocks_per_piece)
, m_num_filtered(0)
, m_num_have_filtered(0)
, m_num_have(0)
@@ -69,13 +68,22 @@ namespace libtorrent
, m_dirty(false)
{
#ifdef TORRENT_PICKER_LOG
- std::cout << "new piece_picker" << std::endl;
+ std::cerr << "new piece_picker" << std::endl;
#endif
+#ifndef NDEBUG
+ check_invariant();
+#endif
+ }
+
+ void piece_picker::init(int blocks_per_piece, int total_num_blocks)
+ {
TORRENT_ASSERT(blocks_per_piece > 0);
TORRENT_ASSERT(total_num_blocks >= 0);
-#ifndef NDEBUG
- m_files_checked_called = false;
-#endif
+
+ // allocate the piece_map to cover all pieces
+ // and make them invalid (as if we don't have a single piece)
+ m_piece_map.resize((total_num_blocks + blocks_per_piece-1) / blocks_per_piece
+ , piece_pos(0, 0));
// the piece index is stored in 20 bits, which limits the allowed
// number of pieces somewhat
@@ -87,15 +95,6 @@ namespace libtorrent
if (m_blocks_in_last_piece == 0) m_blocks_in_last_piece = blocks_per_piece;
TORRENT_ASSERT(m_blocks_in_last_piece <= m_blocks_per_piece);
-
- // allocate the piece_map to cover all pieces
- // and make them invalid (as if we don't have a single piece)
- std::fill(m_piece_map.begin(), m_piece_map.end()
- , piece_pos(0, 0));
- m_num_have = 0;
-#ifndef NDEBUG
- check_invariant();
-#endif
}
void piece_picker::sequential_download(bool sd)
@@ -122,24 +121,6 @@ namespace libtorrent
}
}
- // pieces is a bitmask with the pieces we have
- void piece_picker::init(bitfield const& pieces)
- {
- TORRENT_PIECE_PICKER_INVARIANT_CHECK;
-#ifndef NDEBUG
- m_files_checked_called = true;
-#endif
- int index = 0;
- for (bitfield::const_iterator i = pieces.begin();
- i != pieces.end(); ++i, ++index)
- {
- TORRENT_ASSERT(index < pieces.size());
- piece_pos& p = m_piece_map[index];
- if (*i) we_have(index);
- else TORRENT_ASSERT(p.index == 0);
- }
- }
-
void piece_picker::piece_info(int index, piece_picker::downloading_piece& st) const
{
TORRENT_PIECE_PICKER_INVARIANT_CHECK;
@@ -249,7 +230,7 @@ namespace libtorrent
for (std::vector::const_iterator i = m_priority_boundries.begin()
, end(m_priority_boundries.end()); i != end; ++i)
{
- std::cout << *i << " ";
+ std::cerr << *i << " ";
}
std::cout << std::endl;
int index = 0;
@@ -260,12 +241,12 @@ namespace libtorrent
if (*i == -1) break;
while (j != m_priority_boundries.end() && *j <= index)
{
- std::cout << "| ";
+ std::cerr << "| ";
++j;
}
- std::cout << *i << "(" << m_piece_map[*i].index << ") ";
+ std::cerr << *i << "(" << m_piece_map[*i].index << ") ";
}
- std::cout << std::endl;
+ std::cerr << std::endl;
}
void piece_picker::check_invariant(const torrent* t) const
@@ -534,7 +515,7 @@ namespace libtorrent
else new_index = rand() % (range_end - range_start) + range_start;
#ifdef TORRENT_PICKER_LOG
- std::cout << "add " << index << " (" << priority << ")" << std::endl;
+ std::cerr << "add " << index << " (" << priority << ")" << std::endl;
print_pieces();
#endif
m_pieces.push_back(-1);
@@ -554,7 +535,7 @@ namespace libtorrent
new_index = temp;
#ifdef TORRENT_PICKER_LOG
print_pieces();
- std::cout << " index: " << index
+ std::cerr << " index: " << index
<< " prio: " << priority
<< " new_index: " << new_index
<< std::endl;
@@ -581,7 +562,7 @@ namespace libtorrent
TORRENT_ASSERT(m_sequential_download == -1);
#ifdef TORRENT_PICKER_LOG
- std::cout << "remove " << m_pieces[elem_index] << " (" << priority << ")" << std::endl;
+ std::cerr << "remove " << m_pieces[elem_index] << " (" << priority << ")" << std::endl;
#endif
int next_index = elem_index;
TORRENT_ASSERT(m_piece_map[m_pieces[elem_index]].priority(this) == -1);
@@ -624,7 +605,6 @@ namespace libtorrent
TORRENT_ASSERT(!m_dirty);
TORRENT_ASSERT(priority >= 0);
TORRENT_ASSERT(elem_index >= 0);
- TORRENT_ASSERT(m_files_checked_called);
TORRENT_ASSERT(m_sequential_download == -1);
TORRENT_ASSERT(int(m_priority_boundries.size()) > priority);
@@ -648,7 +628,7 @@ namespace libtorrent
m_priority_boundries.resize(new_priority + 1, m_pieces.size());
#ifdef TORRENT_PICKER_LOG
- std::cout << "update " << index << " (" << priority << "->" << new_priority << ")" << std::endl;
+ std::cerr << "update " << index << " (" << priority << "->" << new_priority << ")" << std::endl;
#endif
if (priority > new_priority)
{
@@ -772,7 +752,6 @@ namespace libtorrent
TORRENT_ASSERT(index >= 0);
TORRENT_ASSERT(index < (int)m_piece_map.size());
- TORRENT_ASSERT(m_files_checked_called);
TORRENT_ASSERT(m_piece_map[index].downloading == 1);
@@ -804,7 +783,6 @@ namespace libtorrent
void piece_picker::inc_refcount_all()
{
TORRENT_PIECE_PICKER_INVARIANT_CHECK;
- TORRENT_ASSERT(m_files_checked_called);
++m_seeds;
if (m_sequential_download >= 0) return;
if (m_seeds == 1)
@@ -819,7 +797,6 @@ namespace libtorrent
void piece_picker::dec_refcount_all()
{
TORRENT_PIECE_PICKER_INVARIANT_CHECK;
- TORRENT_ASSERT(m_files_checked_called);
if (m_sequential_download >= 0)
{
@@ -935,7 +912,7 @@ namespace libtorrent
TORRENT_ASSERT(m_sequential_download == -1);
if (m_priority_boundries.empty()) m_priority_boundries.resize(1, 0);
#ifdef TORRENT_PICKER_LOG
- std::cout << "update_pieces" << std::endl;
+ std::cerr << "update_pieces" << std::endl;
#endif
std::fill(m_priority_boundries.begin(), m_priority_boundries.end(), 0);
for (std::vector::iterator i = m_piece_map.begin()
@@ -1004,6 +981,33 @@ namespace libtorrent
#endif
}
+ void piece_picker::we_dont_have(int index)
+ {
+ TORRENT_PIECE_PICKER_INVARIANT_CHECK;
+ TORRENT_ASSERT(index >= 0);
+ TORRENT_ASSERT(index < (int)m_piece_map.size());
+
+ piece_pos& p = m_piece_map[index];
+ TORRENT_ASSERT(p.downloading == 0);
+
+ if (!p.have()) return;
+
+ if (m_sequential_download > index)
+ m_sequential_download = index;
+
+ if (p.filtered())
+ {
+ ++m_num_filtered;
+ --m_num_have_filtered;
+ }
+
+ --m_num_have;
+ p.set_not_have();
+
+ if (m_dirty) return;
+ if (!p.filtered()) add(index);
+ }
+
// this is used to indicate that we succesfully have
// downloaded a piece, and that no further attempts
// to pick that piece should be made. The piece will
@@ -1167,7 +1171,6 @@ namespace libtorrent
TORRENT_PIECE_PICKER_INVARIANT_CHECK;
TORRENT_ASSERT(num_blocks > 0);
TORRENT_ASSERT(pieces.size() == m_piece_map.size());
- TORRENT_ASSERT(m_files_checked_called);
TORRENT_ASSERT(!m_priority_boundries.empty()
|| m_sequential_download >= 0
diff --git a/src/torrent.cpp b/src/torrent.cpp
index 786655f0d..b41edd2e7 100755
--- a/src/torrent.cpp
+++ b/src/torrent.cpp
@@ -164,7 +164,7 @@ namespace libtorrent
, m_last_dht_announce(time_now() - minutes(15))
#endif
, m_ses(ses)
- , m_picker(0)
+ , m_picker(new piece_picker())
, m_trackers(m_torrent_file->trackers())
, m_total_failed_bytes(0)
, m_total_redundant_bytes(0)
@@ -175,7 +175,6 @@ namespace libtorrent
, m_settings(ses.settings())
, m_storage_constructor(sc)
, m_progress(0.f)
- , m_num_pieces(0)
, m_ratio(0.f)
, m_max_uploads((std::numeric_limits::max)())
, m_num_uploads(0)
@@ -240,7 +239,7 @@ namespace libtorrent
, m_last_dht_announce(time_now() - minutes(15))
#endif
, m_ses(ses)
- , m_picker(0)
+ , m_picker(new piece_picker())
, m_total_failed_bytes(0)
, m_total_redundant_bytes(0)
, m_net_interface(net_interface.address(), 0)
@@ -250,7 +249,6 @@ namespace libtorrent
, m_settings(ses.settings())
, m_storage_constructor(sc)
, m_progress(0.f)
- , m_num_pieces(0)
, m_ratio(0.f)
, m_max_uploads((std::numeric_limits::max)())
, m_num_uploads(0)
@@ -409,16 +407,14 @@ namespace libtorrent
TORRENT_ASSERT(m_torrent_file->num_files() > 0);
TORRENT_ASSERT(m_torrent_file->total_size() >= 0);
- m_have_pieces.resize(m_torrent_file->num_pieces(), false);
// the shared_from_this() will create an intentional
// cycle of ownership, se the hpp file for description.
m_owning_storage = new piece_manager(shared_from_this(), m_torrent_file
, m_save_path, m_ses.m_files, m_ses.m_disk_thread, m_storage_constructor
, m_storage_mode);
m_storage = m_owning_storage.get();
- m_picker.reset(new piece_picker(
- m_torrent_file->piece_length() / m_block_size
- , int((m_torrent_file->total_size()+m_block_size-1)/m_block_size)));
+ m_picker->init(m_torrent_file->piece_length() / m_block_size
+ , int((m_torrent_file->total_size()+m_block_size-1)/m_block_size));
std::vector const& url_seeds = m_torrent_file->url_seeds();
std::copy(url_seeds.begin(), url_seeds.end(), std::inserter(m_web_seeds
@@ -475,8 +471,6 @@ namespace libtorrent
" ]\n";
#endif
}
- m_have_pieces.clear_all();
- m_num_pieces = 0;
m_error = j.str;
pause();
return;
@@ -550,8 +544,6 @@ namespace libtorrent
// there are either no files for this torrent
// or the resume_data was accepted
- m_num_pieces = 0;
- m_have_pieces.clear_all();
if (!fastresume_rejected)
{
TORRENT_ASSERT(m_resume_data.type() == entry::dictionary_t);
@@ -565,8 +557,7 @@ namespace libtorrent
for (int i = 0, end(pieces_str.size()); i < end; ++i)
{
if ((pieces_str[i] & 1) == 0) continue;
- m_have_pieces.set_bit(i);
- ++m_num_pieces;
+ m_picker->we_have(i);
}
}
@@ -589,11 +580,8 @@ namespace libtorrent
if (piece_index < 0 || piece_index >= torrent_file().num_pieces())
continue;
- if (m_have_pieces[piece_index])
- {
- m_have_pieces.clear_bit(piece_index);
- --m_num_pieces;
- }
+ if (m_picker->have_piece(piece_index))
+ m_picker->we_dont_have(piece_index);
entry const* bitmask_ent = i->find_key("bitmask");
if (bitmask_ent == 0 || bitmask_ent->type() != entry::string_t) break;
@@ -619,13 +607,6 @@ namespace libtorrent
}
}
}
-
- int index = 0;
- for (bitfield::const_iterator i = m_have_pieces.begin()
- , end(m_have_pieces.end()); i != end; ++i, ++index)
- {
- if (*i) m_picker->we_have(index);
- }
}
files_checked();
@@ -663,8 +644,6 @@ namespace libtorrent
" ]\n";
#endif
}
- m_have_pieces.clear_all();
- m_num_pieces = 0;
m_error = j.str;
pause();
m_ses.done_checking(shared_from_this());
@@ -673,13 +652,9 @@ namespace libtorrent
m_progress = j.piece / float(torrent_file().num_pieces());
- if (j.offset >= 0 && !m_have_pieces[j.offset])
- {
- m_have_pieces.set_bit(j.offset);
- ++m_num_pieces;
- TORRENT_ASSERT(m_picker);
+ TORRENT_ASSERT(m_picker);
+ if (j.offset >= 0 && !m_picker->have_piece(j.offset))
m_picker->we_have(j.offset);
- }
// we're not done checking yet
// this handler will be called repeatedly until
@@ -984,12 +959,12 @@ namespace libtorrent
const int last_piece = m_torrent_file->num_pieces() - 1;
size_type total_done
- = size_type(m_num_pieces) * m_torrent_file->piece_length();
+ = size_type(num_pieces()) * m_torrent_file->piece_length();
// if we have the last piece, we have to correct
// the amount we have, since the first calculation
// assumed all pieces were of equal size
- if (m_have_pieces[last_piece])
+ if (m_picker->have_piece(last_piece))
{
int corr = m_torrent_file->piece_size(last_piece)
- m_torrent_file->piece_length();
@@ -1015,19 +990,19 @@ namespace libtorrent
return make_tuple(m_torrent_file->total_size()
, m_torrent_file->total_size());
- TORRENT_ASSERT(m_num_pieces >= m_picker->num_have_filtered());
- size_type wanted_done = size_type(m_num_pieces - m_picker->num_have_filtered())
+ TORRENT_ASSERT(num_pieces() >= m_picker->num_have_filtered());
+ size_type wanted_done = size_type(num_pieces() - m_picker->num_have_filtered())
* piece_size;
TORRENT_ASSERT(wanted_done >= 0);
size_type total_done
- = size_type(m_num_pieces) * piece_size;
- TORRENT_ASSERT(m_num_pieces < m_torrent_file->num_pieces());
+ = size_type(num_pieces()) * piece_size;
+ TORRENT_ASSERT(num_pieces() < m_torrent_file->num_pieces());
// if we have the last piece, we have to correct
// the amount we have, since the first calculation
// assumed all pieces were of equal size
- if (m_have_pieces[last_piece])
+ if (m_picker->have_piece(last_piece))
{
TORRENT_ASSERT(total_done >= piece_size);
int corr = m_torrent_file->piece_size(last_piece)
@@ -1056,7 +1031,7 @@ namespace libtorrent
{
int corr = 0;
int index = i->index;
- if (m_have_pieces[index]) continue;
+ if (m_picker->have_piece(index)) continue;
TORRENT_ASSERT(i->finished <= m_picker->blocks_in_piece(index));
#ifndef NDEBUG
@@ -1101,7 +1076,7 @@ namespace libtorrent
= pc->downloading_piece_progress();
if (p)
{
- if (m_have_pieces[p->piece_index])
+ if (m_picker->have_piece(p->piece_index))
continue;
piece_block block(p->piece_index, p->block_index);
@@ -1138,16 +1113,16 @@ namespace libtorrent
wanted_done += i->second;
}
+ TORRENT_ASSERT(total_done <= m_torrent_file->total_size());
+ TORRENT_ASSERT(wanted_done <= m_torrent_file->total_size());
+
#ifndef NDEBUG
if (total_done >= m_torrent_file->total_size())
{
// Thist happens when a piece has been downloaded completely
// but not yet verified against the hash
- std::copy(m_have_pieces.begin(), m_have_pieces.end()
- , std::ostream_iterator(std::cerr, " "));
- std::cerr << std::endl;
- std::cerr << "num_pieces: " << m_num_pieces << std::endl;
+ std::cerr << "num_pieces: " << num_pieces() << std::endl;
std::cerr << "unfinished:" << std::endl;
@@ -1352,7 +1327,7 @@ namespace libtorrent
m_picker->restore_piece(index);
TORRENT_ASSERT(m_storage);
- TORRENT_ASSERT(m_have_pieces[index] == false);
+ TORRENT_ASSERT(m_picker->have_piece(index) == false);
#ifndef NDEBUG
for (std::vector::iterator i = downloaders.begin()
@@ -1488,13 +1463,6 @@ namespace libtorrent
std::set peers;
std::copy(downloaders.begin(), downloaders.end(), std::inserter(peers, peers.begin()));
- if (!m_have_pieces[index])
- m_num_pieces++;
- m_have_pieces.set_bit(index);
-
- TORRENT_ASSERT(std::accumulate(m_have_pieces.begin(), m_have_pieces.end(), 0)
- == m_num_pieces);
-
m_picker->we_have(index);
for (peer_iterator i = m_connections.begin(); i != m_connections.end(); ++i)
(*i)->announce_piece(index);
@@ -1560,7 +1528,7 @@ namespace libtorrent
bool was_finished = is_finished();
bool filter_updated = m_picker->set_piece_priority(index, priority);
- TORRENT_ASSERT(m_num_pieces >= m_picker->num_have_filtered());
+ TORRENT_ASSERT(num_pieces() >= m_picker->num_have_filtered());
if (filter_updated) update_peer_interest(was_finished);
}
@@ -1598,7 +1566,7 @@ namespace libtorrent
TORRENT_ASSERT(*i >= 0);
TORRENT_ASSERT(*i <= 7);
filter_updated |= m_picker->set_piece_priority(index, *i);
- TORRENT_ASSERT(m_num_pieces >= m_picker->num_have_filtered());
+ TORRENT_ASSERT(num_pieces() >= m_picker->num_have_filtered());
}
if (filter_updated) update_peer_interest(was_finished);
}
@@ -2444,8 +2412,16 @@ namespace libtorrent
// write have bitmask
entry::string_type& pieces = ret["pieces"].string();
pieces.resize(m_torrent_file->num_pieces());
- for (int i = 0, end(pieces.size()); i < end; ++i)
- pieces[i] = m_have_pieces[i] ? 1 : 0;
+ if (is_seed())
+ {
+ for (int i = 0, end(pieces.size()); i < end; ++i)
+ pieces[i] = 1;
+ }
+ else
+ {
+ for (int i = 0, end(pieces.size()); i < end; ++i)
+ pieces[i] = m_picker->have_piece(i) ? 1 : 0;
+ }
// write local peers
@@ -3119,7 +3095,6 @@ namespace libtorrent
if (!is_seed())
{
- m_picker->init(m_have_pieces);
if (m_sequential_download)
picker().sequential_download(m_sequential_download);
}
@@ -3293,16 +3268,16 @@ namespace libtorrent
if (!m_picker->is_downloaded(i->first))
TORRENT_ASSERT(m_picker->num_peers(i->first) == i->second);
}
- TORRENT_ASSERT(m_num_pieces >= m_picker->num_have_filtered());
+ TORRENT_ASSERT(num_pieces() >= m_picker->num_have_filtered());
}
if (valid_metadata())
{
- TORRENT_ASSERT(m_abort || int(m_have_pieces.size()) == m_torrent_file->num_pieces());
+ TORRENT_ASSERT(m_abort || !m_picker || m_picker->num_pieces() == m_torrent_file->num_pieces());
}
else
{
- TORRENT_ASSERT(m_abort || m_have_pieces.empty());
+ TORRENT_ASSERT(m_abort || m_picker->num_pieces() == 0);
}
for (policy::const_iterator i = m_policy.begin_peer()
@@ -3317,7 +3292,7 @@ namespace libtorrent
if (is_seed())
TORRENT_ASSERT(total_done == m_torrent_file->total_size());
else
- TORRENT_ASSERT(total_done != m_torrent_file->total_size());
+ TORRENT_ASSERT(total_done != m_torrent_file->total_size() || !m_files_checked);
}
else
{
@@ -3348,8 +3323,6 @@ namespace libtorrent
}
// This check is very expensive.
- TORRENT_ASSERT(m_num_pieces
- == std::count(m_have_pieces.begin(), m_have_pieces.end(), true));
TORRENT_ASSERT(!valid_metadata() || m_block_size > 0);
TORRENT_ASSERT(!valid_metadata() || (m_torrent_file->piece_length() % m_block_size) == 0);
// if (is_seed()) TORRENT_ASSERT(m_picker.get() == 0);
@@ -3821,7 +3794,7 @@ namespace libtorrent
TORRENT_ASSERT(m_storage->refcount() > 0);
TORRENT_ASSERT(piece_index >= 0);
TORRENT_ASSERT(piece_index < m_torrent_file->num_pieces());
- TORRENT_ASSERT(piece_index < (int)m_have_pieces.size());
+ TORRENT_ASSERT(piece_index < (int)m_picker->num_pieces());
#ifndef NDEBUG
if (m_picker)
{
@@ -3872,6 +3845,12 @@ namespace libtorrent
TORRENT_ASSERT(valid_metadata());
fp.clear();
+ if (is_seed())
+ {
+ fp.resize(m_torrent_file->num_files(), 1.f);
+ return;
+ }
+
fp.resize(m_torrent_file->num_files(), 0.f);
for (int i = 0; i < m_torrent_file->num_files(); ++i)
@@ -3892,7 +3871,7 @@ namespace libtorrent
{
size_type bytes_step = (std::min)(size_type(m_torrent_file->piece_size(ret.piece)
- ret.start), size);
- if (m_have_pieces[ret.piece]) done += bytes_step;
+ if (m_picker->have_piece(ret.piece)) done += bytes_step;
++ret.piece;
ret.start = 0;
size -= bytes_step;
@@ -3907,11 +3886,6 @@ namespace libtorrent
{
INVARIANT_CHECK;
- TORRENT_ASSERT(std::accumulate(
- m_have_pieces.begin()
- , m_have_pieces.end()
- , 0) == m_num_pieces);
-
ptime now = time_now();
torrent_status st;
@@ -4038,8 +4012,14 @@ namespace libtorrent
else st.progress = st.total_wanted_done
/ static_cast(st.total_wanted);
- st.pieces = &m_have_pieces;
- st.num_pieces = m_num_pieces;
+ if (has_picker())
+ {
+ int num_pieces = m_picker->num_pieces();
+ st.pieces.resize(num_pieces, false);
+ for (int i = 0; i < num_pieces; ++i)
+ if (m_picker->have_piece(i)) st.pieces.set_bit(i);
+ }
+ st.num_pieces = num_pieces();
st.num_seeds = num_seeds();
if (m_picker.get())
st.distributed_copies = m_picker->distributed_copies();
diff --git a/test/test_piece_picker.cpp b/test/test_piece_picker.cpp
index 6f63f0da5..d65fb6259 100644
--- a/test/test_piece_picker.cpp
+++ b/test/test_piece_picker.cpp
@@ -36,7 +36,8 @@ boost::shared_ptr setup_picker(
const int num_pieces = strlen(availability);
assert(int(strlen(have_str)) == num_pieces);
- boost::shared_ptr p(new piece_picker(blocks_per_piece, num_pieces * blocks_per_piece));
+ boost::shared_ptr p(new piece_picker);
+ p->init(blocks_per_piece, num_pieces * blocks_per_piece);
bitfield have = string2vec(have_str);
@@ -93,11 +94,10 @@ boost::shared_ptr setup_picker(
TEST_CHECK(p->piece_priority(i) == prio);
}
- p->init(have);
-
for (int i = 0; i < num_pieces; ++i)
{
if (!have[i]) continue;
+ p->we_have(i);
for (int j = 0; j < blocks_per_piece; ++j)
TEST_CHECK(p->is_finished(piece_block(i, j)));
}
@@ -152,6 +152,11 @@ void print_pick(std::vector const& picked)
std::cout << std::endl;
}
+void print_title(char const* name)
+{
+ std::cerr << "==== " << name << " ====\n";
+}
+
int test_pick(boost::shared_ptr const& p)
{
std::vector picked;
@@ -174,6 +179,7 @@ int test_main()
// make sure the block that is picked is from piece 1, since it
// it is the piece with the lowest availability
+ print_title("test pick lowest availability");
p = setup_picker("2223333", "* * * ", "", "");
picked.clear();
p->pick_pieces(string2vec("*******"), picked, 1, false, 0, piece_picker::fast, true, false, empty_vector);
@@ -185,6 +191,7 @@ int test_main()
// make sure the block that is picked is from piece 5, since it
// has the highest priority among the available pieces
+ print_title("test pick highest priority");
p = setup_picker("1111111", "* * * ", "1111122", "");
picked.clear();
p->pick_pieces(string2vec("****** "), picked, 1, false, 0, piece_picker::fast, true, false, empty_vector);
@@ -196,6 +203,7 @@ int test_main()
// make sure the 4 blocks are picked from the same piece if
// whole pieces are preferred. The only whole piece is 1.
+ print_title("test pick whole pieces");
p = setup_picker("1111111", " ", "1111111", "1023460");
picked.clear();
p->pick_pieces(string2vec("****** "), picked, 1, 1, &peer_struct, piece_picker::fast, true, true, empty_vector);
@@ -209,6 +217,7 @@ int test_main()
// test the distributed copies function. It should include ourself
// in the availability. i.e. piece 0 has availability 2.
// there are 2 pieces with availability 2 and 5 with availability 3
+ print_title("test distributed copies");
p = setup_picker("1233333", "* ", "", "");
float dc = p->distributed_copies();
TEST_CHECK(fabs(dc - (2.f + 5.f / 7.f)) < 0.01f);
@@ -216,6 +225,7 @@ int test_main()
// ========================================================
// make sure filtered pieces are ignored
+ print_title("test filtered pieces");
p = setup_picker("1111111", " ", "0010000", "");
picked.clear();
p->pick_pieces(string2vec("*** ** "), picked, 1, false, 0, piece_picker::fast, true, false, empty_vector);
@@ -223,9 +233,23 @@ int test_main()
TEST_CHECK(int(picked.size()) > 0);
TEST_CHECK(picked.front().piece_index == 2);
+// ========================================================
+
+ // make sure we_dont_have works
+ print_title("test we_dont_have");
+ p = setup_picker("1111111", "*******", "0100000", "");
+ picked.clear();
+ p->we_dont_have(1);
+ p->we_dont_have(2);
+ p->pick_pieces(string2vec("*** ** "), picked, 1, false, 0, piece_picker::fast, true, false, empty_vector);
+ TEST_CHECK(verify_pick(p, picked));
+ TEST_CHECK(int(picked.size()) > 0);
+ TEST_CHECK(picked.front().piece_index == 1);
+
// ========================================================
// make sure requested blocks aren't picked
+ print_title("test don't pick requested blocks");
p = setup_picker("1234567", " ", "", "");
picked.clear();
p->pick_pieces(string2vec("*******"), picked, 1, false, 0, piece_picker::fast, true, false, empty_vector);
@@ -294,6 +318,7 @@ int test_main()
// ========================================================
// test piece priorities
+ print_title("test piece priorities");
p = setup_picker("5555555", " ", "3214576", "");
TEST_CHECK(p->num_filtered() == 0);
TEST_CHECK(p->num_have_filtered() == 0);
@@ -327,6 +352,7 @@ int test_main()
// ========================================================
// test restore_piece
+ print_title("test restore piece");
p = setup_picker("1234567", " ", "", "");
p->mark_as_finished(piece_block(0,0), 0);
p->mark_as_finished(piece_block(0,1), 0);
@@ -380,6 +406,7 @@ int test_main()
// ========================================================
// test non-rarest-first mode
+ print_title("test not rarest first");
p = setup_picker("1234567", "* * * ", "1111122", "");
picked.clear();
p->pick_pieces(string2vec("****** "), picked, 5 * blocks_per_piece, false, 0, piece_picker::fast, false, false, empty_vector);
@@ -397,6 +424,7 @@ int test_main()
// ========================================================
// test have_all and have_none
+ print_title("test have_all and have_none");
p = setup_picker("0123333", "* ", "", "");
dc = p->distributed_copies();
std::cout << "distributed copies: " << dc << std::endl;
@@ -413,6 +441,7 @@ int test_main()
// ========================================================
// test inc_ref and dec_ref
+ print_title("test inc_ref dec_ref");
p = setup_picker("1233333", " * ", "", "");
TEST_CHECK(test_pick(p) == 0);
@@ -464,6 +493,7 @@ int test_main()
// ========================================================
// 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)) == 0);
@@ -503,6 +533,7 @@ int test_main()
// ========================================================
// test prefer_whole_pieces
+ print_title("test prefer whole pieces");
p = setup_picker("1111111", " ", "", "");
picked.clear();
p->pick_pieces(string2vec("*******"), picked, 1, 3, 0, piece_picker::fast, true, false, empty_vector);
@@ -533,6 +564,7 @@ int test_main()
// ========================================================
// test parole mode
+ print_title("test parole mode");
p = setup_picker("3333133", " ", "", "");
p->mark_as_finished(piece_block(0, 0), 0);
picked.clear();
@@ -561,6 +593,7 @@ int test_main()
// ========================================================
// test suggested pieces
+ print_title("test suggested pieces");
p = setup_picker("1111222233334444", " ", "", "");
int v[] = {1, 5};
std::vector suggested_pieces(v, v + 2);