1 /* Copyright (c) 2012-2019. The SimGrid Team. All rights reserved. */
3 /* This program is free software; you can redistribute it and/or modify it
4 * under the terms of the license (GNU LGPL) which comes with this package. */
9 #include "s4u-peer.hpp"
10 #include "s4u-tracker.hpp"
12 XBT_LOG_NEW_DEFAULT_CATEGORY(s4u_bt_peer, "Messages specific for the peers");
15 * User parameters for transferred file data. For the test, the default values are :
16 * File size: 10 pieces * 5 blocks/piece * 16384 bytes/block = 819200 bytes
18 #define FILE_PIECES 10UL
19 #define PIECES_BLOCKS 5UL
20 #define BLOCK_SIZE 16384
22 /** Number of blocks asked by each request */
23 #define BLOCKS_REQUESTED 2UL
25 #define ENABLE_END_GAME_MODE 1
26 #define SLEEP_DURATION 1
27 #define BITS_TO_BYTES(x) (((x) / 8 + (x) % 8) ? 1 : 0)
29 Peer::Peer(std::vector<std::string> args)
32 xbt_assert(args.size() == 3 || args.size() == 4, "Wrong number of arguments");
34 id = std::stoi(args[1]);
35 mailbox_ = simgrid::s4u::Mailbox::by_name(std::to_string(id));
36 } catch (std::invalid_argument& ia) {
37 throw std::invalid_argument(std::string("Invalid ID:") + args[1].c_str());
41 deadline = std::stod(args[2]);
42 } catch (std::invalid_argument& ia) {
43 throw std::invalid_argument(std::string("Invalid deadline:") + args[2].c_str());
45 xbt_assert(deadline > 0, "Wrong deadline supplied");
47 stream = simgrid::s4u::this_actor::get_host()->extension<HostBittorrent>()->getStream();
49 if (args.size() == 4 && args[3] == "1") {
50 bitfield_ = (1U << FILE_PIECES) - 1U;
51 bitfield_blocks = (1ULL << (FILE_PIECES * PIECES_BLOCKS)) - 1ULL;
53 pieces_count = new short[FILE_PIECES]{0};
55 XBT_INFO("Hi, I'm joining the network with id %d", id);
60 for (auto const& peer : connected_peers)
62 delete[] pieces_count;
65 /** Peer main function */
66 void Peer::operator()()
68 // Getting peer data from the tracker.
69 if (getPeersFromTracker()) {
70 XBT_DEBUG("Got %zu peers from the tracker. Current status is: %s", connected_peers.size(), getStatus().c_str());
71 begin_receive_time = simgrid::s4u::Engine::get_clock();
72 mailbox_->set_receiver(simgrid::s4u::Actor::self());
74 sendHandshakeToAllPeers();
80 XBT_INFO("Couldn't contact the tracker.");
83 XBT_INFO("Here is my current status: %s", getStatus().c_str());
86 bool Peer::getPeersFromTracker()
88 simgrid::s4u::MailboxPtr tracker_mailbox = simgrid::s4u::Mailbox::by_name(TRACKER_MAILBOX);
89 // Build the task to send to the tracker
90 TrackerQuery* peer_request = new TrackerQuery(id, mailbox_);
92 XBT_DEBUG("Sending a peer request to the tracker.");
93 tracker_mailbox->put(peer_request, TRACKER_COMM_SIZE, GET_PEERS_TIMEOUT);
94 } catch (simgrid::TimeoutError& e) {
95 XBT_DEBUG("Timeout expired when requesting peers to tracker");
101 TrackerAnswer* answer = static_cast<TrackerAnswer*>(mailbox_->get(GET_PEERS_TIMEOUT));
102 // Add the peers the tracker gave us to our peer list.
103 for (auto const& peer_id : *answer->getPeers())
105 connected_peers[peer_id] = new Connection(peer_id);
107 } catch (simgrid::TimeoutError& e) {
108 XBT_DEBUG("Timeout expired when requesting peers to tracker");
114 void Peer::sendHandshakeToAllPeers()
116 for (auto const& kv : connected_peers) {
117 Connection* remote_peer = kv.second;
118 Message* handshake = new Message(MESSAGE_HANDSHAKE, id, mailbox_);
119 remote_peer->mailbox_->put_init(handshake, MESSAGE_HANDSHAKE_SIZE)->detach();
120 XBT_DEBUG("Sending a HANDSHAKE to %d", remote_peer->id);
124 void Peer::sendMessage(simgrid::s4u::MailboxPtr mailbox, e_message_type type, uint64_t size)
126 const char* type_names[6] = {"HANDSHAKE", "CHOKE", "UNCHOKE", "INTERESTED", "NOTINTERESTED", "CANCEL"};
127 XBT_DEBUG("Sending %s to %s", type_names[type], mailbox->get_cname());
128 mailbox->put_init(new Message(type, id, bitfield_, mailbox_), size)->detach();
131 void Peer::sendBitfield(simgrid::s4u::MailboxPtr mailbox)
133 XBT_DEBUG("Sending a BITFIELD to %s", mailbox->get_cname());
135 ->put_init(new Message(MESSAGE_BITFIELD, id, bitfield_, mailbox_),
136 MESSAGE_BITFIELD_SIZE + BITS_TO_BYTES(FILE_PIECES))
140 void Peer::sendPiece(simgrid::s4u::MailboxPtr mailbox, unsigned int piece, int block_index, int block_length)
142 xbt_assert(not hasNotPiece(piece), "Tried to send a unavailable piece.");
143 XBT_DEBUG("Sending the PIECE %u (%d,%d) to %s", piece, block_index, block_length, mailbox->get_cname());
144 mailbox->put_init(new Message(MESSAGE_PIECE, id, mailbox_, piece, block_index, block_length), BLOCK_SIZE)->detach();
147 void Peer::sendHaveToAllPeers(unsigned int piece)
149 XBT_DEBUG("Sending HAVE message to all my peers");
150 for (auto const& kv : connected_peers) {
151 Connection* remote_peer = kv.second;
152 remote_peer->mailbox_->put_init(new Message(MESSAGE_HAVE, id, mailbox_, piece), MESSAGE_HAVE_SIZE)->detach();
156 void Peer::sendRequestTo(Connection* remote_peer, unsigned int piece)
158 remote_peer->current_piece = piece;
159 xbt_assert(remote_peer->hasPiece(piece));
160 int block_index = getFirstMissingBlockFrom(piece);
161 if (block_index != -1) {
162 int block_length = std::min(BLOCKS_REQUESTED, PIECES_BLOCKS - block_index);
163 XBT_DEBUG("Sending a REQUEST to %s for piece %u (%d,%d)", remote_peer->mailbox_->get_cname(), piece, block_index,
165 remote_peer->mailbox_
166 ->put_init(new Message(MESSAGE_REQUEST, id, mailbox_, piece, block_index, block_length), MESSAGE_REQUEST_SIZE)
171 std::string Peer::getStatus()
173 std::string res = std::string("");
174 for (int i = FILE_PIECES - 1; i >= 0; i--)
175 res = std::string((bitfield_ & (1U << i)) ? "1" : "0") + res;
179 bool Peer::hasFinished()
181 return bitfield_ == (1U << FILE_PIECES) - 1U;
184 /** Indicates if the remote peer has a piece not stored by the local peer */
185 bool Peer::isInterestedBy(Connection* remote_peer)
187 return remote_peer->bitfield & (bitfield_ ^ ((1 << FILE_PIECES) - 1));
190 bool Peer::isInterestedByFree(Connection* remote_peer)
192 for (unsigned int i = 0; i < FILE_PIECES; i++)
193 if (hasNotPiece(i) && remote_peer->hasPiece(i) && isNotDownloadingPiece(i))
198 void Peer::updatePiecesCountFromBitfield(unsigned int bitfield)
200 for (unsigned int i = 0; i < FILE_PIECES; i++)
201 if (bitfield & (1U << i))
205 unsigned int Peer::countPieces(unsigned int bitfield)
207 unsigned int count = 0U;
208 unsigned int n = bitfield;
216 int Peer::nbInterestedPeers()
219 for (auto const& kv : connected_peers)
220 if (kv.second->interested)
227 double next_choked_update = simgrid::s4u::Engine::get_clock() + UPDATE_CHOKED_INTERVAL;
228 XBT_DEBUG("Start downloading.");
230 /* Send a "handshake" message to all the peers it got (since it couldn't have gotten more than 50 peers) */
231 sendHandshakeToAllPeers();
232 XBT_DEBUG("Starting main leech loop listening on mailbox: %s", mailbox_->get_cname());
234 void* data = nullptr;
235 while (simgrid::s4u::Engine::get_clock() < deadline && countPieces(bitfield_) < FILE_PIECES) {
236 if (comm_received == nullptr) {
237 comm_received = mailbox_->get_async(&data);
239 if (comm_received->test()) {
240 message = static_cast<Message*>(data);
243 comm_received = nullptr;
245 // We don't execute the choke algorithm if we don't already have a piece
246 if (simgrid::s4u::Engine::get_clock() >= next_choked_update && countPieces(bitfield_) > 0) {
248 next_choked_update += UPDATE_CHOKED_INTERVAL;
250 simgrid::s4u::this_actor::sleep_for(SLEEP_DURATION);
255 XBT_DEBUG("%d becomes a seeder", id);
260 double next_choked_update = simgrid::s4u::Engine::get_clock() + UPDATE_CHOKED_INTERVAL;
261 XBT_DEBUG("Start seeding.");
262 // start the main seed loop
263 void* data = nullptr;
264 while (simgrid::s4u::Engine::get_clock() < deadline) {
265 if (comm_received == nullptr) {
266 comm_received = mailbox_->get_async(&data);
268 if (comm_received->test()) {
269 message = static_cast<Message*>(data);
272 comm_received = nullptr;
274 if (simgrid::s4u::Engine::get_clock() >= next_choked_update) {
276 // TODO: Change the choked peer algorithm when seeding.
277 next_choked_update += UPDATE_CHOKED_INTERVAL;
279 simgrid::s4u::this_actor::sleep_for(SLEEP_DURATION);
285 void Peer::updateActivePeersSet(Connection* remote_peer)
287 if (remote_peer->interested && not remote_peer->choked_upload)
288 active_peers.insert(remote_peer);
290 active_peers.erase(remote_peer);
293 void Peer::handleMessage()
295 const char* type_names[10] = {"HANDSHAKE", "CHOKE", "UNCHOKE", "INTERESTED", "NOTINTERESTED",
296 "HAVE", "BITFIELD", "REQUEST", "PIECE", "CANCEL"};
298 XBT_DEBUG("Received a %s message from %s", type_names[message->type], message->return_mailbox->get_cname());
300 auto known_peer = connected_peers.find(message->peer_id);
301 Connection* remote_peer = (known_peer == connected_peers.end()) ? nullptr : known_peer->second;
302 xbt_assert(remote_peer != nullptr || message->type == MESSAGE_HANDSHAKE,
303 "The impossible did happened: A not-in-our-list peer sent us a message.");
305 switch (message->type) {
306 case MESSAGE_HANDSHAKE:
307 // Check if the peer is in our connection list.
308 if (remote_peer == nullptr) {
309 XBT_DEBUG("This peer %d was unknown, answer to its handshake", message->peer_id);
310 connected_peers[message->peer_id] = new Connection(message->peer_id);
311 sendMessage(message->return_mailbox, MESSAGE_HANDSHAKE, MESSAGE_HANDSHAKE_SIZE);
313 // Send our bitfield to the peer
314 sendBitfield(message->return_mailbox);
316 case MESSAGE_BITFIELD:
317 // Update the pieces list
318 updatePiecesCountFromBitfield(message->bitfield);
319 // Store the bitfield
320 remote_peer->bitfield = message->bitfield;
321 xbt_assert(not remote_peer->am_interested, "Should not be interested at first");
322 if (isInterestedBy(remote_peer)) {
323 remote_peer->am_interested = true;
324 sendMessage(message->return_mailbox, MESSAGE_INTERESTED, MESSAGE_INTERESTED_SIZE);
327 case MESSAGE_INTERESTED:
328 // Update the interested state of the peer.
329 remote_peer->interested = true;
330 updateActivePeersSet(remote_peer);
332 case MESSAGE_NOTINTERESTED:
333 remote_peer->interested = false;
334 updateActivePeersSet(remote_peer);
336 case MESSAGE_UNCHOKE:
337 xbt_assert(remote_peer->choked_download);
338 remote_peer->choked_download = false;
339 // Send requests to the peer, since it has unchoked us
340 if (remote_peer->am_interested)
341 requestNewPieceTo(remote_peer);
344 xbt_assert(not remote_peer->choked_download);
345 remote_peer->choked_download = true;
346 if (remote_peer->current_piece != -1)
347 removeCurrentPiece(remote_peer, remote_peer->current_piece);
350 XBT_DEBUG("\t for piece %d", message->piece);
351 xbt_assert((message->piece >= 0 && static_cast<unsigned int>(message->piece) < FILE_PIECES),
352 "Wrong HAVE message received");
353 remote_peer->bitfield = remote_peer->bitfield | (1U << static_cast<unsigned int>(message->piece));
354 pieces_count[message->piece]++;
355 // If the piece is in our pieces, we tell the peer that we are interested.
356 if (not remote_peer->am_interested && hasNotPiece(message->piece)) {
357 remote_peer->am_interested = true;
358 sendMessage(message->return_mailbox, MESSAGE_INTERESTED, MESSAGE_INTERESTED_SIZE);
359 if (not remote_peer->choked_download)
360 requestNewPieceTo(remote_peer);
363 case MESSAGE_REQUEST:
364 xbt_assert(remote_peer->interested);
365 xbt_assert((message->piece >= 0 && static_cast<unsigned int>(message->piece) < FILE_PIECES),
366 "Wrong HAVE message received");
367 if (not remote_peer->choked_upload) {
368 XBT_DEBUG("\t for piece %d (%d,%d)", message->piece, message->block_index,
369 message->block_index + message->block_length);
370 if (not hasNotPiece(message->piece)) {
371 sendPiece(message->return_mailbox, message->piece, message->block_index, message->block_length);
374 XBT_DEBUG("\t for piece %d but he is choked.", message->peer_id);
378 XBT_DEBUG(" \t for piece %d (%d,%d)", message->piece, message->block_index,
379 message->block_index + message->block_length);
380 xbt_assert(not remote_peer->choked_download);
381 xbt_assert(remote_peer->am_interested || ENABLE_END_GAME_MODE,
382 "Can't received a piece if I'm not interested without end-game mode!"
383 "piece (%d) bitfield (%u) remote bitfield (%u)",
384 message->piece, bitfield_, remote_peer->bitfield);
385 xbt_assert(not remote_peer->choked_download, "Can't received a piece if I'm choked !");
386 xbt_assert((message->piece >= 0 && static_cast<unsigned int>(message->piece) < FILE_PIECES),
387 "Wrong piece received");
388 // TODO: Execute a computation.
389 if (hasNotPiece(static_cast<unsigned int>(message->piece))) {
390 updateBitfieldBlocks(message->piece, message->block_index, message->block_length);
391 if (hasCompletedPiece(static_cast<unsigned int>(message->piece))) {
392 // Removing the piece from our piece list
393 removeCurrentPiece(remote_peer, message->piece);
394 // Setting the fact that we have the piece
395 bitfield_ = bitfield_ | (1U << static_cast<unsigned int>(message->piece));
396 XBT_DEBUG("My status is now %s", getStatus().c_str());
397 // Sending the information to all the peers we are connected to
398 sendHaveToAllPeers(message->piece);
399 // sending UNINTERESTED to peers that do not have what we want.
400 updateInterestedAfterReceive();
401 } else { // piece not completed
402 sendRequestTo(remote_peer, message->piece); // ask for the next block
405 XBT_DEBUG("However, we already have it");
406 xbt_assert(ENABLE_END_GAME_MODE, "Should not happen because we don't use end game mode !");
407 requestNewPieceTo(remote_peer);
415 // Update the peer speed.
417 remote_peer->addSpeedValue(1.0 / (simgrid::s4u::Engine::get_clock() - begin_receive_time));
419 begin_receive_time = simgrid::s4u::Engine::get_clock();
422 /** Selects the appropriate piece to download and requests it to the remote_peer */
423 void Peer::requestNewPieceTo(Connection* remote_peer)
425 int piece = selectPieceToDownload(remote_peer);
427 current_pieces |= (1U << (unsigned int)piece);
428 sendRequestTo(remote_peer, piece);
432 void Peer::removeCurrentPiece(Connection* remote_peer, unsigned int current_piece)
434 current_pieces &= ~(1U << current_piece);
435 remote_peer->current_piece = -1;
438 /** @brief Return the piece to be downloaded
439 * There are two cases (as described in "Bittorrent Architecture Protocol", Ryan Toole :
440 * If a piece is partially downloaded, this piece will be selected prioritarily
441 * If the peer has strictly less than 4 pieces, he chooses a piece at random.
442 * If the peer has more than pieces, he downloads the pieces that are the less replicated (rarest policy).
443 * If all pieces have been downloaded or requested, we select a random requested piece (endgame mode).
444 * @param remote_peer: information about the connection
445 * @return the piece to download if possible. -1 otherwise
447 int Peer::selectPieceToDownload(Connection* remote_peer)
449 int piece = partiallyDownloadedPiece(remote_peer);
450 // strict priority policy
455 if (countPieces(current_pieces) >= (FILE_PIECES - countPieces(bitfield_)) && isInterestedBy(remote_peer)) {
456 #if ENABLE_END_GAME_MODE == 0
459 int nb_interesting_pieces = 0;
460 // compute the number of interesting pieces
461 for (unsigned int i = 0; i < FILE_PIECES; i++)
462 if (hasNotPiece(i) && remote_peer->hasPiece(i))
463 nb_interesting_pieces++;
465 xbt_assert(nb_interesting_pieces != 0);
466 // get a random interesting piece
467 int random_piece_index = RngStream_RandInt(stream, 0, nb_interesting_pieces - 1);
468 int current_index = 0;
469 for (unsigned int i = 0; i < FILE_PIECES; i++) {
470 if (hasNotPiece(i) && remote_peer->hasPiece(i)) {
471 if (random_piece_index == current_index) {
478 xbt_assert(piece != -1);
481 // Random first policy
482 if (countPieces(bitfield_) < 4 && isInterestedByFree(remote_peer)) {
483 int nb_interesting_pieces = 0;
484 // compute the number of interesting pieces
485 for (unsigned int i = 0; i < FILE_PIECES; i++)
486 if (hasNotPiece(i) && remote_peer->hasPiece(i) && isNotDownloadingPiece(i))
487 nb_interesting_pieces++;
488 xbt_assert(nb_interesting_pieces != 0);
489 // get a random interesting piece
490 int random_piece_index = RngStream_RandInt(stream, 0, nb_interesting_pieces - 1);
491 int current_index = 0;
492 for (unsigned int i = 0; i < FILE_PIECES; i++) {
493 if (hasNotPiece(i) && remote_peer->hasPiece(i) && isNotDownloadingPiece(i)) {
494 if (random_piece_index == current_index) {
501 xbt_assert(piece != -1);
503 } else { // Rarest first policy
504 short min = SHRT_MAX;
505 int nb_min_pieces = 0;
506 int current_index = 0;
507 // compute the smallest number of copies of available pieces
508 for (unsigned int i = 0; i < FILE_PIECES; i++) {
509 if (pieces_count[i] < min && hasNotPiece(i) && remote_peer->hasPiece(i) && isNotDownloadingPiece(i))
510 min = pieces_count[i];
513 xbt_assert(min != SHRT_MAX || not isInterestedByFree(remote_peer));
514 // compute the number of rarest pieces
515 for (unsigned int i = 0; i < FILE_PIECES; i++)
516 if (pieces_count[i] == min && hasNotPiece(i) && remote_peer->hasPiece(i) && isNotDownloadingPiece(i))
519 xbt_assert(nb_min_pieces != 0 || not isInterestedByFree(remote_peer));
520 // get a random rarest piece
521 int random_rarest_index = RngStream_RandInt(stream, 0, nb_min_pieces - 1);
522 for (unsigned int i = 0; i < FILE_PIECES; i++)
523 if (pieces_count[i] == min && hasNotPiece(i) && remote_peer->hasPiece(i) && isNotDownloadingPiece(i)) {
524 if (random_rarest_index == current_index) {
531 xbt_assert(piece != -1 || not isInterestedByFree(remote_peer));
536 void Peer::updateChokedPeers()
538 if (nbInterestedPeers() == 0)
540 XBT_DEBUG("(%d) update_choked peers %zu active peers", id, active_peers.size());
541 // update the current round
542 round_ = (round_ + 1) % 3;
543 Connection* chosen_peer = nullptr;
544 // select first active peer and remove it from the set
545 Connection* choked_peer;
546 if (active_peers.empty()) {
547 choked_peer = nullptr;
549 choked_peer = *active_peers.begin();
550 active_peers.erase(choked_peer);
553 /**If we are currently seeding, we unchoke the peer which has been unchoked the last time.*/
555 Connection* remote_peer;
556 double unchoke_time = simgrid::s4u::Engine::get_clock() + 1;
557 for (auto const& kv : connected_peers) {
558 remote_peer = kv.second;
559 if (remote_peer->last_unchoke < unchoke_time && remote_peer->interested && remote_peer->choked_upload) {
560 unchoke_time = remote_peer->last_unchoke;
561 chosen_peer = remote_peer;
565 // Random optimistic unchoking
569 // We choose a random peer to unchoke.
570 std::unordered_map<int, Connection*>::iterator chosen_peer_it = connected_peers.begin();
571 std::advance(chosen_peer_it, RngStream_RandInt(stream, 0, connected_peers.size() - 1));
572 chosen_peer = chosen_peer_it->second;
573 if (chosen_peer == nullptr)
574 THROWF(unknown_error, 0, "A peer should have be selected at this point");
575 else if (not chosen_peer->interested || not chosen_peer->choked_upload)
576 chosen_peer = nullptr;
578 XBT_DEBUG("Nothing to do, keep going");
580 } while (chosen_peer == nullptr && j < MAXIMUM_PEERS);
582 // Use the "fastest download" policy.
583 double fastest_speed = 0.0;
584 for (auto const& kv : connected_peers) {
585 Connection* remote_peer = kv.second;
586 if (remote_peer->peer_speed > fastest_speed && remote_peer->choked_upload && remote_peer->interested) {
587 chosen_peer = remote_peer;
588 fastest_speed = remote_peer->peer_speed;
594 if (chosen_peer != nullptr)
595 XBT_DEBUG("(%d) update_choked peers unchoked (%d) ; int (%d) ; choked (%d) ", id, chosen_peer->id,
596 chosen_peer->interested, chosen_peer->choked_upload);
598 if (choked_peer != chosen_peer) {
599 if (choked_peer != nullptr) {
600 xbt_assert(not choked_peer->choked_upload, "Tries to choked a choked peer");
601 choked_peer->choked_upload = true;
602 updateActivePeersSet(choked_peer);
603 XBT_DEBUG("(%d) Sending a CHOKE to %d", id, choked_peer->id);
604 sendMessage(choked_peer->mailbox_, MESSAGE_CHOKE, MESSAGE_CHOKE_SIZE);
606 if (chosen_peer != nullptr) {
607 xbt_assert((chosen_peer->choked_upload), "Tries to unchoked an unchoked peer");
608 chosen_peer->choked_upload = false;
609 active_peers.insert(chosen_peer);
610 chosen_peer->last_unchoke = simgrid::s4u::Engine::get_clock();
611 XBT_DEBUG("(%d) Sending a UNCHOKE to %d", id, chosen_peer->id);
612 updateActivePeersSet(chosen_peer);
613 sendMessage(chosen_peer->mailbox_, MESSAGE_UNCHOKE, MESSAGE_UNCHOKE_SIZE);
618 /** @brief Update "interested" state of peers: send "not interested" to peers that don't have any more pieces we want.*/
619 void Peer::updateInterestedAfterReceive()
621 for (auto const& kv : connected_peers) {
622 Connection* remote_peer = kv.second;
623 if (remote_peer->am_interested) {
624 bool interested = false;
625 // Check if the peer still has a piece we want.
626 for (unsigned int i = 0; i < FILE_PIECES; i++)
627 if (hasNotPiece(i) && remote_peer->hasPiece(i)) {
632 if (not interested) { // no more piece to download from connection
633 remote_peer->am_interested = false;
634 sendMessage(remote_peer->mailbox_, MESSAGE_NOTINTERESTED, MESSAGE_NOTINTERESTED_SIZE);
640 void Peer::updateBitfieldBlocks(int piece, int block_index, int block_length)
642 xbt_assert((piece >= 0 && static_cast<unsigned int>(piece) <= FILE_PIECES), "Wrong piece.");
643 xbt_assert((block_index >= 0 && static_cast<unsigned int>(block_index) <= PIECES_BLOCKS), "Wrong block : %d.",
645 for (int i = block_index; i < (block_index + block_length); i++)
646 bitfield_blocks |= (1ULL << static_cast<unsigned int>(piece * PIECES_BLOCKS + i));
649 bool Peer::hasCompletedPiece(unsigned int piece)
651 for (unsigned int i = 0; i < PIECES_BLOCKS; i++)
652 if (not(bitfield_blocks & 1ULL << (piece * PIECES_BLOCKS + i)))
657 int Peer::getFirstMissingBlockFrom(int piece)
659 for (unsigned int i = 0; i < PIECES_BLOCKS; i++)
660 if (not(bitfield_blocks & 1ULL << (piece * PIECES_BLOCKS + i)))
665 /** Returns a piece that is partially downloaded and stored by the remote peer if any -1 otherwise. */
666 int Peer::partiallyDownloadedPiece(Connection* remote_peer)
668 for (unsigned int i = 0; i < FILE_PIECES; i++)
669 if (hasNotPiece(i) && remote_peer->hasPiece(i) && isNotDownloadingPiece(i) && getFirstMissingBlockFrom(i) > 0)