ModelChannelSurf2Cat.cpp

#include "Headers.h"
#include "ModelChannelSurf2Cat.h"
#include "Rand.h"

CModelChannelSurf2Cat::CModelChannelSurf2Cat(
    __uint32    numChannels,
    __uint32    numPopular,
    double      probSurfing,
    double      probPopular,
    double      probSurfForward,
    double      probSurfCycle
    ) : CModelChannelData(numChannels)
{
    this->numPopular = numPopular;
    this->probSurfing = (__uint32)(0xFFFFFFFF * probSurfing);
    this->probPopular = (__uint32)(0xFFFFFFFF * probPopular);
    this->probSurfForward = (__uint32)(0xFFFFFFFF * probSurfForward);
    this->probSurfCycle = (__uint32)(0xFFFFFFFF * probSurfCycle);

    // Calculate the surfing threshold - the smallest duration for which the probability is greater or equal to the surfing probability
    if(0 == this->probSurfing)
        this->surfThreshold = 0;
    else
    {
        for(__uint32 index = 0; index < CDF_POINTS; index++)
            if(channelCdf[index][1] >= this->probSurfing)
            {
                this->surfThreshold = channelCdf[index][0];
                index = CDF_POINTS;
            }
    }
}

void CModelChannelSurf2Cat::GenerateUptime(__uint32 &newCh, __time &duration)
{
    __uint32 pr = CRand::GenerateUInt32();
    __uint32 ch = CRand::GenerateUInt32();
    __uint32 dindex;

//#ifndef DETRAND
//  rand_s(&pr);
//  rand_s(&ch);
//#else
//  pr = (((__uint32)rand()) << 17) | (((__uint32)rand()) << 2) | (((__uint32)rand()) & 0x3);
//  ch = (((__uint32)rand()) << 17) | (((__uint32)rand()) << 2) | (((__uint32)rand()) & 0x3);
//#endif

    dindex = channelCdfIndex[pr >> 15];
    duration = channelCdf[dindex][0];
    
    pr = CRand::GenerateUInt32();
//#ifndef DETRAND
//  rand_s(&pr);
//#else
//  pr = (((__uint32)rand()) << 17) | (((__uint32)rand()) << 2) | (((__uint32)rand()) & 0x3);
//#endif

    // Generate new channel (a random channel)
    if(pr < this->probPopular)
        newCh = (__uint32)(((__uint64)ch)*this->numPopular/0x100000000LL);
    else
        newCh = this->numPopular + (__uint32)(((__uint64)ch)*(this->numChannels-this->numPopular-1)/0x100000000LL);
}

void CModelChannelSurf2Cat::GenerateUptime(__uint32 oldCh, __time oldDuration, __uint32 &newCh, __time &duration)
{
    __uint32 pr = CRand::GenerateUInt32();
    __uint32 prb = CRand::GenerateUInt32();
    __uint32 ch = CRand::GenerateUInt32();
    __uint32 dindex;
    
//#ifndef DETRAND
//  rand_s(&pr);
//#else
//  pr = (((__uint32)rand()) << 17) | (((__uint32)rand()) << 2) | (((__uint32)rand()) & 0x3);
//#endif

    dindex = channelCdfIndex[pr >> 15];
    duration = channelCdf[dindex][0];

    pr = CRand::GenerateUInt32();
//#ifndef DETRAND
//  rand_s(&ch);
//  rand_s(&pr);
//  rand_s(&prb);
//#else
//  pr = (((__uint32)rand()) << 17) | (((__uint32)rand()) << 2) | (((__uint32)rand()) & 0x3);
//  ch = (((__uint32)rand()) << 17) | (((__uint32)rand()) << 2) | (((__uint32)rand()) & 0x3);
//  prb = (((__uint32)rand()) << 17) | (((__uint32)rand()) << 2) | (((__uint32)rand()) & 0x3);
//#endif

    if(oldDuration < this->surfThreshold)
    {
        // Surfing

        // Check if surfing forward or backward
        if(pr < this->probSurfForward)
        {
            // Surfing forward
            // Check if old channel is M-1 or N-1
            if(oldCh == this->numPopular-1)
            {
                if(prb < this->probSurfCycle) newCh = 0;    // Cycle surfing
                else newCh = this->numPopular;              // Normal surfing
            }
            else if(oldCh == this->numChannels-1)
            {
                if(prb < this->probSurfCycle) newCh = this->numPopular; // Cycle surfing
                else newCh = 0;                                         // Normal surfing
            }
            else
                newCh = oldCh + 1;
        }
        else
        {
            // Surfing backward
            // Check is old channel is 0 or M
            if(oldCh == 0)
            {
                if(prb < this->probSurfCycle) newCh = this->numPopular-1;   // Cycle surfing
                else newCh = this->numChannels-1;                           // Normal surfing
            }
            else if(oldCh == this->numPopular)
            {
                if(prb < this->probSurfCycle) newCh = this->numChannels-1;  // Cycle surfing
                else newCh = this->numPopular-1;                            // Normal surfing
            }
            else
                newCh = oldCh - 1;
        }
    }
    else
    {
        // Switch
        if(pr < this->probPopular)
        {
            // Switch to popular channel
            if(oldCh < this->numPopular)
            {
                newCh = (__uint32)(((__uint64)ch)*(this->numPopular-1)/0x100000000LL);
                if(newCh >= oldCh) newCh++;
            }
            else
                newCh = (__uint32)(((__uint64)ch)*this->numPopular/0x100000000LL);
        }
        else
        {
            // Switch to unpopular channel
            if(oldCh < this->numPopular)
                newCh = this->numPopular + (__uint32)(((__uint64)ch)*(this->numChannels-this->numPopular)/0x100000000LL);
            else
            {
                newCh = this->numPopular + (__uint32)(((__uint64)ch)*(this->numChannels-this->numPopular-1)/0x100000000LL);
                if(newCh >= oldCh) newCh++;
            }
        }
    }
    assert(newCh != oldCh);
    assert(newCh < this->numChannels);
}

__uint32 CModelChannelSurf2Cat::Cdf(__uint32 dindex)
{
    return channelCdf[dindex][0];
}