void Peer::updateChokedPeers()
{
if (nbInterestedPeers() == 0)
return;
XBT_DEBUG("(%d) update_choked peers %zu active peers", id, active_peers.size());
// update the current round
round_ = (round_ + 1) % 3;
Connection* chosen_peer = nullptr;
// select first active peer and remove it from the set
Connection* choked_peer;
if (active_peers.empty()) {
choked_peer = nullptr;
} else {
choked_peer = *active_peers.begin();
active_peers.erase(choked_peer);
}
/**If we are currently seeding, we unchoke the peer which has been unchoked the last time.*/
if (hasFinished()) {
Connection* remote_peer;
double unchoke_time = simgrid::s4u::Engine::get_clock() + 1;
for (auto const& kv : connected_peers) {
remote_peer = kv.second;
if (remote_peer->last_unchoke < unchoke_time && remote_peer->interested && remote_peer->choked_upload) {
unchoke_time = remote_peer->last_unchoke;
chosen_peer = remote_peer;
}
}
} else {
// Random optimistic unchoking
if (round_ == 0) {
int j = 0;
do {
// We choose a random peer to unchoke.
std::unordered_map<int, Connection*>::iterator chosen_peer_it = connected_peers.begin();
std::advance(chosen_peer_it, RngStream_RandInt(stream, 0, connected_peers.size() - 1));
chosen_peer = chosen_peer_it->second;
if (chosen_peer == nullptr)
THROWF(unknown_error, 0, "A peer should have be selected at this point");
else if (not chosen_peer->interested || not chosen_peer->choked_upload)
chosen_peer = nullptr;
else
XBT_DEBUG("Nothing to do, keep going");
j++;
} while (chosen_peer == nullptr && j < MAXIMUM_PEERS);
} else {
// Use the "fastest download" policy.
double fastest_speed = 0.0;
for (auto const& kv : connected_peers) {
Connection* remote_peer = kv.second;
if (remote_peer->peer_speed > fastest_speed && remote_peer->choked_upload && remote_peer->interested) {
chosen_peer = remote_peer;
fastest_speed = remote_peer->peer_speed;
}
}
}
}
if (chosen_peer != nullptr)
XBT_DEBUG("(%d) update_choked peers unchoked (%d) ; int (%d) ; choked (%d) ", id, chosen_peer->id,
chosen_peer->interested, chosen_peer->choked_upload);
if (choked_peer != chosen_peer) {
if (choked_peer != nullptr) {
xbt_assert(not choked_peer->choked_upload, "Tries to choked a choked peer");
choked_peer->choked_upload = true;
updateActivePeersSet(choked_peer);
XBT_DEBUG("(%d) Sending a CHOKE to %d", id, choked_peer->id);
sendMessage(choked_peer->mailbox_, MESSAGE_CHOKE, MESSAGE_CHOKE_SIZE);
}
if (chosen_peer != nullptr) {
xbt_assert((chosen_peer->choked_upload), "Tries to unchoked an unchoked peer");
chosen_peer->choked_upload = false;
active_peers.insert(chosen_peer);
chosen_peer->last_unchoke = simgrid::s4u::Engine::get_clock();
XBT_DEBUG("(%d) Sending a UNCHOKE to %d", id, chosen_peer->id);
updateActivePeersSet(chosen_peer);
sendMessage(chosen_peer->mailbox_, MESSAGE_UNCHOKE, MESSAGE_UNCHOKE_SIZE);
}
}
}
bool AudioBufferSourceNode::propagatesSilence() const
{
return !isPlayingOrScheduled() || hasFinished() || !m_buffer;
}
void KonqRun::foundMimeType(const QString & _type)
{
//kDebug() << "KonqRun::foundMimeType " << _type << " m_req=" << m_req.debug();
QString mimeType = _type; // this ref comes from the job, we lose it when using KIO again
m_bFoundMimeType = true;
if (m_pView)
m_pView->setLoading(false); // first phase finished, don't confuse KonqView
// Check if the main window wasn't deleted meanwhile
if (!m_pMainWindow) {
setError(true);
setFinished(true);
return;
}
// Grab the args back from BrowserRun
m_req.args = arguments();
m_req.browserArgs = browserArguments();
bool tryEmbed = true;
// One case where we shouldn't try to embed, is when the server asks us to save
if (serverSuggestsSave())
tryEmbed = false;
const bool associatedAppIsKonqueror = KonqMainWindow::isMimeTypeAssociatedWithSelf(mimeType);
if (tryEmbed && tryOpenView(mimeType, associatedAppIsKonqueror)) {
return;
}
// If we were following another view, do nothing if opening didn't work.
if (m_req.followMode) {
setFinished(true);
}
if (!hasFinished()) {
// If we couldn't embed the mimetype, call BrowserRun::handleNonEmbeddable()
KService::Ptr selectedService;
KParts::BrowserRun::NonEmbeddableResult res = handleNonEmbeddable(mimeType, &selectedService);
if (res == KParts::BrowserRun::Delayed)
return;
setFinished(res == KParts::BrowserRun::Handled);
if (hasFinished()) {
// save or cancel -> nothing else will happen in m_pView, so clear statusbar (#163628)
m_pView->frame()->statusbar()->slotClear();
} else {
if (!tryEmbed) {
// "Open" selected for a serverSuggestsSave() file - let's open. #171869
if (tryOpenView(mimeType, associatedAppIsKonqueror))
return;
}
// "Open" selected, possible with a specific application
if (selectedService)
KRun::setPreferredService(selectedService->desktopEntryName());
else {
KRun::displayOpenWithDialog(url(), m_pMainWindow, false /*tempfile*/, suggestedFileName());
setFinished(true);
}
}
}
// make Konqueror think there was an error, in order to stop the spinning wheel
// (we saved, canceled, or we're starting another app... in any case the current view should stop loading).
setError(true);
if (!hasFinished()) { // only if we're going to open
if (associatedAppIsKonqueror && m_pMainWindow->refuseExecutingKonqueror(mimeType)) {
setFinished(true);
}
}
if (!hasFinished()) {
kDebug() << "Nothing special to do in KonqRun, falling back to KRun";
KRun::foundMimeType(mimeType);
}
}
