Choker.cpp

Go to the documentation of this file.

/*

Copyright (C) 2006-2007 by Peter Dimov.

This file is part of Calitko (http://www.calitko.org).

Calitko is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

Calitko is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Calitko; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

*/

#include "Qt.h"
#include "Choker.h"
#include "TransferSession.h"
#include "Imports.cpp"


Choker::Choker (Timer *timer,
                RandomNumberGenerator *randomNumberGenerator,
                TransferManagerState *transferManagerState)
 :  timer (timer), randomNumberGenerator (randomNumberGenerator),
    transferManagerState (transferManagerState),
    sessions(), newSessions(), optimisticlyUnchokedSessions(),
    optimisticChokingCounter (0)
{
}

Choker::~Choker()
{
}

void Choker::start()
{
    // \todo assert if already started??
    timer->start (Callable <void()> (this, &Choker::chokingTime),
                  ChokingTimeout);
}

void Choker::stop()
{
    timer->stop();
}

void Choker::openedSession (TransferSession *session)
{
    sessions += session;
    newSessions += session;
}

void Choker::incomingPacket (TransferSession *, const Packet &)
{
    // Nothing to do here.
}

void Choker::outgoingPacket (TransferSession *, const Packet &)
{
    // Nothing to do here.
}


void Choker::closedSession (TransferSession *session)
{
    sessions.removeAll (session);
    newSessions.removeAll (session);
}

void Choker::chokingTime()
{
    doOptimisticUnchokingIfTimeHasCome();
    sortSessionsForSelection();
    reallocateUploadSlotsAndChokeUnchokeSessions();
}


void Choker::doOptimisticUnchokingIfTimeHasCome()
{
    ++optimisticChokingCounter;
    if (optimisticChokingCounter == OptimisticChokingRate) {
        optimisticChokingCounter = 0;
        optimisticlyUnchokedSessions = choseOptimisticlyUnchokedSessions();
        foreach (TransferSession *session, optimisticlyUnchokedSessions) {
            // The state of session selected for optimistic unchoke is only set
            // here and may not be modified (i.e. no choking/unchoking).
            Q_ASSERT (session->isPeerChoked());
            session->sendPacket (unchoke);
        }
    }
}


Choker::Sessions Choker::choseOptimisticlyUnchokedSessions()
{
    Sessions chokedSessions;
    int numberOfSessionsSnubbed = 0;
    foreach (TransferSession *session, sessions) {
        // No seeders are optimistic unchoke candidates:
        if (session->isPeerChoked() && !session->isPeerSeeder()) {
            chokedSessions += session;
            // "Newly connected peers are three times as likely to start as the
            // current optimistic unchoke as anywhere else in the rotation."
            if (newSessions.contains (session)) {
                chokedSessions += session; // two times more likely
                chokedSessions += session; // three times more likely
            }
        }
        // Only do an optimistic unchoke for a snubbed session if downloading:
        if (session->areWeSnubbed() && transferManagerState->isDownloading())
            ++numberOfSessionsSnubbed;
    }
    newSessions.clear();

    // Add an extra optimistic unchoke for each unchoked peer that snubbed us:
    Sessions optimisticUnchokes;
    for (int i = numberOfSessionsSnubbed + 1;
         i > 0 && !chokedSessions.isEmpty();
         --i) {
        int index = randomNumberGenerator->random() % chokedSessions.size();
        TransferSession *luckySession = chokedSessions.at (index);
        optimisticUnchokes += luckySession;
        // New connections are added multiple times, make sure all are removed:
        chokedSessions.removeAll (luckySession);
    }
    return optimisticUnchokes;
}


void Choker::sortSessionsForSelection()
{
    if (transferManagerState->isDownloading())
        qStableSort (sessions.begin(), sessions.end(),
                     moreDownloadedAndMoreInterested);
    else
        qStableSort (sessions.begin(), sessions.end(),
                     moreUploadedAndMoreInterested);
}


void Choker::reallocateUploadSlotsAndChokeUnchokeSessions()
{
    int uploadSlotsLeft = numberOfUploadSlots();

    foreach (TransferSession *session, sessions) {
        // We don't change the status of an optimisticly unchoked session:
        if (optimisticlyUnchokedSessions.contains (session))
            continue;

        if (uploadSlotsLeft > 0 && !session->isPeerSeeder())
            unchokeSessionIfNeeded (session);
        else
            chokeSessionIfNeeded (session);
        // Decrease uploadSlotsLeft only if the other peer is interested, which
        // means it would use the slot we are offering to it.
        if (session->isPeerInterested())
            --uploadSlotsLeft;
    }
}


int Choker::numberOfUploadSlots() const
{
    int uploadSlots = UploadSlotsCount;

    foreach (TransferSession *session, optimisticlyUnchokedSessions)
        if (session->isPeerInterested())
            --uploadSlots;

    return uploadSlots;
}

void Choker::chokeSessionIfNeeded (TransferSession *session)
{
    if (!session->isPeerChoked())
        session->sendPacket (choke);
}

void Choker::unchokeSessionIfNeeded (TransferSession *session)
{
    if (session->isPeerChoked())
        session->sendPacket (unchoke);
}


bool Choker::moreDownloadedAndMoreInterested (const TransferSession *a,
                                              const TransferSession *b)
{
    qint64 aSpeed = a->currentDownloadSpeed();
    qint64 bSpeed = b->currentDownloadSpeed();

    if (aSpeed > bSpeed)
        return true;
    else if (aSpeed == bSpeed)
        return a->isPeerInterested() > b->isPeerInterested();
    else
        return false;
}


bool Choker::moreUploadedAndMoreInterested (const TransferSession *a,
                                            const TransferSession *b)
{
    qint64 aSpeed = a->currentUploadSpeed();
    qint64 bSpeed = b->currentUploadSpeed();

    if (aSpeed > bSpeed)
        return true;
    else if (aSpeed == bSpeed)
        return a->isPeerInterested() > b->isPeerInterested();
    else
        return false;
}

const Choke Choker::choke; // \todo use some kind of factory? the first choke packet will only need to be rebuilt once!
const Unchoke Choker::unchoke; // \todo see above todo

Copyright © 2006 Peter Dimov.
Powered by Doxygen.