ModelSelectProbRange.cpp

#include "Headers.h"
#include "ModelSelectProbRange.h"
#include "Rand.h"

CModelSelectProbRange::CModelSelectProbRange(
    unsigned int    numChannels,
    unsigned int    numLayers,
    unsigned int    numPeers,
    CProb*          prob,
    double          delta
) : CModelSelect(numChannels, numLayers, numPeers)
{
    this->prob = prob;
    this->delta = 1 - delta;

    // Allocate candidate peers
    this->candidates = new SCandidate[this->numPeers];
}

CModelSelectProbRange::~CModelSelectProbRange()
{
    delete[] this->candidates;
}

CPeer** CModelSelectProbRange::Select(__time time, __uint32 channel, __uint32 child)
{
    assert(channel < this->numChannels);
    assert(child < this->numPeers);

    CPeer* peerChild = &this->peers[child];

    for(__uint32 layer = 0; layer < this->numLayers; layer++)
    {
        double maxProb = 0;
        double minProb;
        unsigned int countCandidates = 0;
        unsigned int countRange = 0;

        for(set<CPeer*>::iterator iter = this->index[channel].begin(); iter != this->index[channel].end(); iter++)
        {
            if(!this->IsResult(*iter, layer))
            {
                if(peerChild->VerifyParent(channel, layer, *iter))
                {
                    // Calculating the maximum probability
                    double prob = this->prob->Prob((*iter)->Elapsed(time, channel), peerChild->Elapsed(time, channel));
                    if(maxProb < prob) maxProb = prob;

                    // Build the list of candidate peers meeting bandwidth and parent constraints
                    this->candidates[countCandidates].peer = *iter;
                    this->candidates[countCandidates++].prob = prob;
                }
            }
        }

        // Calculate minimum probability
        minProb = maxProb * this->delta;

        // Select the candidates with a probability in the range: maxProb * delta ... maxProb
        for(unsigned int index = 0; index < countCandidates; index++)
        {
            if(this->candidates[index].prob >= minProb)
            {
                this->candidates[countRange++] = this->candidates[index];
            }
        }

        // Select a random peer
        this->result[layer] = countRange ? this->candidates[CRand::Generate(countRange)].peer : NULL;
    }

    return this->result;
}

CPeer* CModelSelectProbRange::Select(__time time, __uint32 channel, __uint32 layer, __uint32 child)
{
    assert(channel < this->numChannels);
    assert(child < this->numPeers);

    CPeer* peerChild = &this->peers[child];

    double maxProb = 0;
    double minProb;
    unsigned int countCandidates = 0;
    unsigned int countRange = 0;

    for(set<CPeer*>::iterator iter = this->index[channel].begin(); iter != this->index[channel].end(); iter++)
    {
        if(!this->IsResult(*iter, layer))
        {
            if(peerChild->VerifyParent(channel, layer, *iter))
            {
                // Calculating the maximum probability
                double prob = this->prob->Prob((*iter)->Elapsed(time, channel), peerChild->Elapsed(time, channel));
                if(maxProb < prob) maxProb = prob;

                // Build the list of candidate peers meeting bandwidth and parent constraints
                this->candidates[countCandidates].peer = *iter;
                this->candidates[countCandidates++].prob = prob;
            }
        }
    }

    // Calculate minimum probability
    minProb = maxProb * this->delta;

    // Select the candidates with a probability in the range: maxProb * delta ... maxProb
    for(unsigned int index = 0; index < countCandidates; index++)
    {
        if(this->candidates[index].prob >= minProb)
        {
            this->candidates[countRange++] = this->candidates[index];
        }
    }

    // Select a random peer
    return countRange ? this->candidates[CRand::Generate(countRange)].peer : NULL;
}