Minstrel_he.c

/************************************************************************************
* Copyright (C) 2023                                                               *
* TETCOS, Bangalore. India                                                         *
*                                                                                  *
* The code Minstrel Rate Control algorithm is provided per GNU GPLv2 licensing     *
*                                                                                  *
* Author: HESUOFDM@IITM                                                                *
*                                                                                  *
* ---------------------------------------------------------------------------------*/
#include "Minstrel_he.h"
 
#define HE_GROUP_RATES 12       //number of rates per group in 802.11ax
#define HE_BANDWIDTHS   4       //number of bandwidths 20, 40, 80 and 160MHz
#define HE_NSS  8               //number of special streams
#define HE_GROUPS 96            //number of groups (bandwidth,sgi,nss)
 
#define HE_GetRateId(index,isHe) (int)(index%HE_GROUP_RATES)
#define HE_GetGroupId(index,isHe) (int)(index/HE_GROUP_RATES)
#define HE_GetIndex(grpId,rateId,isHe) (int)(grpId*HE_GROUP_RATES + rateId)
#define HE_IsEqual(b1,g1,s1,b2,g2,s2) ((b1 == b2 && g1 == g2 && s1 ==s2) ? true:false) 
 
#define HE_SEED_r &NETWORK->ppstruDeviceList[0]->ulSeed[0],&NETWORK->ppstruDeviceList[0]->ulSeed[1]
#define HE_rand01() (fn_NetSim_Utilities_GenerateRandomNo(HE_SEED_r)/NETSIM_RAND_MAX)
#define HE_tSlot(phy) (phy->plmeCharacteristics.aSlotTime)
#define HE_ackTime(phy) (phy->plmeCharacteristics.aSIFSTime + get_preamble_time(phy) + (getAckSize(phy) * 8)/phy->dControlFrameDataRate)
#define HE_firstTransmissionTime(phy,byte,rate) (phy->plmeCharacteristics.aSIFSTime + get_preamble_time(phy)+ byte*8/rate)
#define HE_transmissionTime(phy,byte,rate) (byte*8/rate)
 
static Ptr_MinstrelHePerRemoteStation He_getMinstrelInfo(NETSIM_ID dev,NETSIM_ID ifid,NETSIM_ID recv)
{
    Ptr_MinstrelHeWifiStation station = IEEE802_11_PHY(dev,ifid)->rateAdaptationData;
    return station->minstrelHeInfo[recv];
}
 
 
void He_InitMinstrel(NETSIM_ID nDevId,NETSIM_ID nifid){
    NETSIM_ID i;
    Ptr_MinstrelHeWifiStation heWifiStation;
    //initialize the Minstrel global variables
    he_updateStatsTime = 100*1000;  //100 ms 
    he_lookAroundRate= 10;
    he_sampleCol = 12;
    he_ewmaWeight = 25;
 
    heWifiStation = (Ptr_MinstrelHeWifiStation)calloc(1,sizeof(MinstrelHeWifiStation));
    heWifiStation->minstrelHeInfo = (Ptr_MinstrelHePerRemoteStation*)calloc(NETWORK->nDeviceCount+1,sizeof(Ptr_MinstrelHePerRemoteStation));        
    heWifiStation->devId = nDevId;
    heWifiStation->interfaceId = nifid;
    for(i=0;i<=NETWORK->nDeviceCount;i++){
    heWifiStation->minstrelHeInfo[i] = (Ptr_MinstrelHePerRemoteStation)calloc(1,sizeof(MinstrelHePerRemoteStation));
    heWifiStation->minstrelHeInfo[i]->remoteStationId = i;
    heWifiStation->minstrelHeInfo[i]->stationId = nDevId;
    heWifiStation->minstrelHeInfo[i]->stationInterface = nifid;
    He_CheckInit(heWifiStation->minstrelHeInfo[i],nDevId,nifid);
    }
    IEEE802_11_PHY(nDevId,nifid)->rateAdaptationData = heWifiStation;
}
 
static void He_CheckInit(Ptr_MinstrelHePerRemoteStation station,NETSIM_ID devid,NETSIM_ID ifid){    //fill
    if(!station->isInitialized){
    station->nextStatsUpdate = ldEventTime + he_updateStatsTime;
    station->ampduLen = 0;
    station->ampduPacketCount = 0;
    station->avgAmpduLen = 1;
        
    station->isInitialized= true;
    station->isSampling= false;
    station->isHe= (IEEE802_11_PHY(devid,ifid)->PhyType==HE);
    station->longRetry= 0;
    station->shortRetry= 0;
    station->totalRetry= 0;
 
    station->maxTpRate = 0;
    station->maxTpRate2= 0;
    station->maxProbRate= 0;
    if(station->isHe){
        station->nGroup= HE_GROUPS;
        station->nGroupRate= HE_GROUP_RATES;
    }
        
    station->phy = IEEE802_11_PHY(devid,ifid);
    station->sampleCount = 16;
    station->sampleGroup= 0;
    station->sampleSlow= 0;
    station->sampleTries= 4;
    station->sampleWait= 0;
 
    station->samplePacketCount= 0;
    station->totalPacketCount= 0;
 
    station->trRate= 0;
    station->sampleRate = 0;
 
    He_InitGroupTable(station);
    He_InitSampleTable(station);
    }
}
 
static void He_InitSampleTable(Ptr_MinstrelHePerRemoteStation station){
    UINT i,j;
    //Memory allocation for Sample Table
    station->sampleTable = calloc(station->nGroupRate, sizeof(UINT*));
    for(i=0;i<station->nGroupRate;i++){
    station->sampleTable[i] = calloc(he_sampleCol,sizeof(UINT));
    for(j=0;j<he_sampleCol;j++)
        station->sampleTable[i][j] = 10000;
        //memset(station->sampleTable[i],10000,sampleCol*sizeof(UINT));
    }
 
    //Randomly filling table with values [0,nRate-1]
    for(j=0;j<he_sampleCol;j++){
    for(i=0;i<station->nGroupRate;i++){
        //generate the random number
        int random_var = (int)(station->nGroupRate*HE_rand01());
        random_var = (i+random_var)%station->nGroupRate;
 
        while(station->sampleTable[random_var][j] != 10000){
        random_var = (random_var + 1)%station->nGroupRate;
        }
        station->sampleTable[random_var][j] = i;
    }
    }
}
 
static void He_InitGroupTable(Ptr_MinstrelHePerRemoteStation station){
    //sort order of groups is: BW -> SGI -> #streams
    UINT i,j,ch,sgi,nss,maxCh,maxNss,startid;
    struct stru_802_11_Phy_Parameters_HE* PhyArray;
    station->groupTable = calloc(station->nGroup,sizeof(HE_GroupInfo));
    maxCh=160;
    maxNss=8;
 
    i=0;
    for(ch=20;ch<=maxCh;ch*=2){     //bandwidth
    for(sgi=800;sgi<=3200;sgi*=2){      //sgi
 
        if(sgi == 800)      //NetSim requirement see IEEE802_11_HEPhy.c HESUOFDM-4
        startid = 0;
        else if (sgi == 1600)
        startid = 12;
            else
                startid = 24;
 
        for(nss=1;nss<=maxNss;nss++){       //#streams
        PhyArray= get_phy_parameter_HE((double)ch,nss);
        //check if group is supported           //fill
 
        if(HE_IsEqual(ch,sgi,nss,station->phy->dChannelBandwidth,station->phy->nGuardInterval,station->phy->NSS))
            station->groupTable[i].supported = true;
        else
            station->groupTable[i].supported = false;
                
        if(station->groupTable[i].supported){
            station->groupTable[i].chWidth= ch;
            station->groupTable[i].col= 0;
            station->groupTable[i].maxProbRate=0;
            station->groupTable[i].maxTpRate= 0;
            station->groupTable[i].maxTpRate2= 0;
            station->groupTable[i].row= 0;
            station->groupTable[i].sgi = sgi;
            station->groupTable[i].streams = nss;
 
            station->groupTable[i].rateTable = calloc(station->nGroupRate,sizeof(HeRateInfo));
 
            for(j=0;j<station->nGroupRate;j++){
            station->groupTable[i].rateTable[j].currNumAttempt = 0;
            station->groupTable[i].rateTable[j].currNumSuccess = 0;
            station->groupTable[i].rateTable[j].ewmaProb= 0;
            station->groupTable[i].rateTable[j].ewmsdProb = 0;
            station->groupTable[i].rateTable[j].numSampleSkipped= 0;
            //station->groupTable[i].rateTable[j].perfectTrTime = ; //fill
            station->groupTable[i].rateTable[j].prevNumAttempt= 0;
            station->groupTable[i].rateTable[j].prevNumSuccess= 0;
            station->groupTable[i].rateTable[j].prob= 0;
            station->groupTable[i].rateTable[j].rate= PhyArray[j+startid].dDataRate;
            station->groupTable[i].rateTable[j].retryCount= 0;
            station->groupTable[i].rateTable[j].retryUpdated= false;
            station->groupTable[i].rateTable[j].throughput= 0;
            station->groupTable[i].rateTable[j].totalNumAttempt= 0;
            station->groupTable[i].rateTable[j].totalNumSuccess= 0;
 
            if(station->groupTable[i].rateTable[j].rate <= 0)
                station->groupTable[i].rateTable[j].supported= false;//fill
            else
                station->groupTable[i].rateTable[j].supported= true;
            }
 
        }
        i++;
        }
    }
    }
    station->maxTpRate= He_GetHighestIndex(station);
    station->maxTpRate2 = He_GetLowestIndex(station);
    station->maxProbRate = He_GetLowestIndex(station);
    station->trRate = station->maxTpRate;
 
}
 
void He_DoReportAmpduStatus(NETSIM_ID devid,NETSIM_ID ifid,NETSIM_ID recvid,UINT success,UINT failed){
    UINT groupId, rateId;
    Ptr_MinstrelHePerRemoteStation station = He_getMinstrelInfo(devid,ifid,recvid);
    if(!station->isInitialized)
    return;
 
    //update ampdu variables
    station->ampduPacketCount++;
    station->ampduLen += success + failed;
 
    //update station packet counters
    He_UpdatePacketCounter(station,success,failed);     //fill
    groupId = HE_GetGroupId(station->trRate,station->isHe);     //fill
    rateId = HE_GetRateId(station->trRate,station->isHe);       //fill
 
    //update rate counters
    station->groupTable[groupId].rateTable[rateId].currNumAttempt += success + failed;
    station->groupTable[groupId].rateTable[rateId].currNumSuccess += success;
 
    if(success== 0 && station->longRetry < He_CountRetries(station)){
    //Not a single success..Entire A-MPDU failed
    He_UpdateRate(station);         //fill
    }
    else{
    station->isSampling = false;
    He_UpdateRetry(station);            //fill
        
    if(ldEventTime >= station->nextStatsUpdate)
        He_UpdateStats(station);            //fill
 
    station->trRate = He_FindRate(station);             //fill
    }
}
 
static void He_UpdatePacketCounter(Ptr_MinstrelHePerRemoteStation station,UINT success,UINT failed){
    station->totalPacketCount += success + failed;
    //if sampling update samplecount
    if(station->isSampling){
    station->samplePacketCount += success + failed;
    }
 
    //wraparound
    if(station->totalPacketCount < 0){
    station->samplePacketCount = 0;
    station->totalPacketCount = 0;
    }
 
    if(station->sampleWait == 0 && station->sampleTries == 0 && station->sampleCount > 0){
    station->sampleWait = (UINT)(16 + 2*station->avgAmpduLen);
    station->sampleTries = 1;
    station->sampleCount--;
    }
}
 
static void He_UpdateRetry(Ptr_MinstrelHePerRemoteStation station){
    station->totalRetry += station->longRetry + station->shortRetry;
    station->shortRetry = 0;
    station->longRetry = 0;
}
 
static void He_UpdateStats(Ptr_MinstrelHePerRemoteStation station){
    //Call this function after the scheduled update
    double tempProb;
    UINT i,j;
    station->nextStatsUpdate = ldEventTime + he_updateStatsTime;
    station->sampleCount = 0;
    station->sampleSlow = 0;
 
    if(station->ampduPacketCount > 0){
    double newLen = station->ampduLen / station->ampduPacketCount ;
    //exponentially weighted average MPDUs per A-MPDU
    station->avgAmpduLen = (newLen* he_ewmaWeight + station->avgAmpduLen*(100- he_ewmaWeight))/100;
    station->ampduLen = 0;
    station->ampduPacketCount = 0;
    }
 
    //update stats for each group and each rate
    for(i=0;i<station->nGroup;i++){
    if (!station->groupTable[i].supported)
        continue;
    for(j=0;j<station->nGroupRate;j++){
        //check if rate is supported
        if(station->groupTable[i].rateTable[j].supported){
        //try to sample all available rates during each interval
        station->sampleCount++;
        station->groupTable[i].rateTable[j].retryUpdated = false;
 
        //if we have attempted something
        if(station->groupTable[i].rateTable[j].currNumAttempt > 0){
            station->groupTable[i].rateTable[j].numSampleSkipped = 0;
            tempProb = (18000* station->groupTable[i].rateTable[j].currNumSuccess)/station->groupTable[i].rateTable[j].currNumAttempt;
            tempProb = tempProb/18000;
 
            station->groupTable[i].rateTable[j].prob= tempProb;
 
            //if updating the rate for the first time
            if(station->groupTable[i].rateTable[j].totalNumAttempt == 0){
            station->groupTable[i].rateTable[j].ewmaProb = tempProb;
            }
            //take weighted average
            else{
            station->groupTable[i].rateTable[j].ewmsdProb = He_CalculateEwmsd(station->groupTable[i].rateTable[j].ewmsdProb,tempProb,station->groupTable[i].rateTable[j].ewmaProb,he_ewmaWeight);   //fill
 
            //EWMA probability
            tempProb = (tempProb * he_ewmaWeight + (100 - he_ewmaWeight)*station->groupTable[i].rateTable[j].ewmaProb)/100;
            station->groupTable[i].rateTable[j].ewmaProb = tempProb;
            }
                    
            station->groupTable[i].rateTable[j].throughput = He_CalculateThroughput(station,i,j); //fill
 
        }
        //nothing is attempted at this rate
        else{
            station->groupTable[i].rateTable[j].numSampleSkipped++;
        }
            
        station->groupTable[i].rateTable[j].totalNumAttempt += station->groupTable[i].rateTable[j].currNumAttempt;
        station->groupTable[i].rateTable[j].totalNumSuccess += station->groupTable[i].rateTable[j].currNumSuccess;
        station->groupTable[i].rateTable[j].prevNumAttempt = station->groupTable[i].rateTable[j].currNumAttempt;
        station->groupTable[i].rateTable[j].prevNumSuccess = station->groupTable[i].rateTable[j].currNumSuccess;
        station->groupTable[i].rateTable[j].currNumAttempt = 0;
        station->groupTable[i].rateTable[j].currNumSuccess = 0;
        }
    }
    }
    //update the group and station max rates
    He_SetStationThRate(station);           //fill
    He_SetStationProbRate(station);     //fill
 
    //Calculate Retransmits..changed based on AMpdu values
    He_CalculateRetransmits(station,station->maxTpRate);        //fill
    He_CalculateRetransmits(station,station->maxTpRate2);
    He_CalculateRetransmits(station,station->maxProbRate);
}
 
static void He_UpdateRate(Ptr_MinstrelHePerRemoteStation station){
   /**
   * Retry Chain table is implemented here.
   * Note this Retry Chain is different from Legacy Minstrel.
   *
   * Try |     LOOKAROUND RATE     | NORMAL RATE
   * -------------------------------------------------------
   *  1  |  Random rate            | Best throughput
   *  2  |  Next best throughput   | Next best throughput
   *  3  |  Best probability       | Best probability
   *
   * Note: For clarity, multiple blocks of if's and else's are used
   * Following implementation in Linux, in MinstrelHE Lowest baserate is not used.
   * Explanation can be found here: http://marc.info/?l=linux-wireless&m=144602778611966&w=2
   */
    UINT maxTpRateId, maxTpGrpId, maxTp2RateId, maxTp2GrpId, maxProbRateId, maxProbGrpId;
    if(!station->isInitialized)
    return;
 
    station->longRetry++;
 
    maxTpRateId = HE_GetRateId(station->maxTpRate ,station->isHe);
    maxTpGrpId = HE_GetGroupId(station->maxTpRate, station->isHe);
    maxTp2RateId = HE_GetRateId(station->maxTpRate2, station->isHe);
    maxTp2GrpId = HE_GetGroupId(station->maxTpRate2, station->isHe);
    maxProbRateId = HE_GetRateId(station->maxProbRate, station->isHe);
    maxProbGrpId = HE_GetGroupId(station->maxProbRate, station->isHe);
 
 
    //for normal rates
    if (!station->isSampling) {
    //use best rate
    if (station->longRetry < station->groupTable[maxTpGrpId].rateTable[maxTpRateId].retryCount)
        station->trRate = station->maxTpRate;
 
    // Use second best throughput rate.
    else if (station->longRetry < (station->groupTable[maxTpGrpId].rateTable[maxTpRateId].retryCount + station->groupTable[maxTp2GrpId].rateTable[maxTp2RateId].retryCount)) {
        station->trRate = station->maxTpRate2;
    }
    //Use best probability rate
    else if (station->longRetry <= (station->groupTable[maxTpGrpId].rateTable[maxTpRateId].retryCount + station->groupTable[maxTp2GrpId].rateTable[maxTp2RateId].retryCount + station->groupTable[maxProbGrpId].rateTable[maxProbRateId].retryCount)) {
        station->trRate = station->maxProbRate;
    }
    else {
        fnNetSimError("Invalid Retry Condition..!");
    }
 
    }
    //for lookaround rates
    else{
        //sample rate is used only once
    //use 2nd best rate **FIXME..!**
    if(station->longRetry < 1 + station->groupTable[maxTp2GrpId].rateTable[maxTp2RateId].retryCount){
        station->trRate = station->maxTpRate2;
    }
    //use the best proability rate
    else if(station->longRetry >= 1 + station->groupTable[maxTp2GrpId].rateTable[maxTp2RateId].retryCount){
        station->trRate = station->maxProbRate;
    }
    else{
        fnNetSimError("Invalid Retry Condition..!");
    }
    }
}
 
static UINT He_FindRate(Ptr_MinstrelHePerRemoteStation station){
    if(station->totalPacketCount == 0){
    return station->maxTpRate;
    }
    //if we have waited enough then sample
    if(station->sampleWait == 0 && station->sampleTries != 0){
    //sampling
    UINT sampleIdx = He_GetNextSample(station);     //fill
    //evaluate if the sample rate should be used
    UINT sampleGroupId = HE_GetGroupId(sampleIdx,station->isHe);
    UINT sampleRateId = HE_GetRateId(sampleIdx,station->isHe);
 
    //use sample rate only if it is supported
    if(station->groupTable[sampleGroupId].supported && station->groupTable[sampleGroupId].rateTable[sampleRateId].supported){
        /*dont use sampling for the currently used rates
        * also dont use sampling if probability is already higher than 95%
        * to avoid wasting airtime */
        if(sampleIdx != station->maxTpRate && sampleIdx != station->maxTpRate2 && sampleIdx != station->maxProbRate && station->groupTable[sampleGroupId].rateTable[sampleRateId].ewmaProb <= 95){
            
        UINT maxTp2GrpId = HE_GetGroupId(station->maxTpRate2,station->isHe);
        UINT maxTp2RateId = HE_GetRateId(station->maxTpRate2,station->isHe);
        UINT maxProbRateId = HE_GetRateId(station->maxProbRate,station->isHe);
        UINT maxProbGrpId = HE_GetGroupId(station->maxProbRate, station->isHe);
 
        UINT sampleRate = (UINT)station->groupTable[sampleGroupId].rateTable[sampleRateId].rate;
        UINT maxTp2Rate = (UINT)station->groupTable[maxTp2GrpId].rateTable[maxTp2RateId].rate;
        UINT maxProbRate = (UINT)station->groupTable[maxProbGrpId].rateTable[maxProbRateId].rate;
 
        UINT sampleStream = station->groupTable[sampleGroupId].streams;
        UINT maxTpStream = station->groupTable[maxTp2GrpId].streams;
                        
        /* Make sure that lower rates get sampled only occasionally,
        * if the link is working perfectly */
        if(sampleRate > maxTp2Rate || (sampleStream <= maxTpStream -1 && sampleRate > maxProbRate)){
            //set flag for currently sampling
            station->isSampling = true;
            //set the sample rate
            station->sampleRate = sampleIdx;
            station->sampleTries--;
            return sampleIdx;
        }
        else{
            if(station->groupTable[sampleGroupId].rateTable[sampleRateId].numSampleSkipped >= 20 && station->sampleSlow++ <=2){
            //set flag for sampling
            station->isSampling = true;
            //set the sample rate
            station->sampleRate = sampleIdx;
            station->sampleTries--;
            return sampleIdx;
            }
        }
        }
    }
    }
    if(station->sampleWait > 0)
    station->sampleWait--;
 
    //Continue using best rate
    return station->maxTpRate;
}
 
static void He_SetStationThRate(Ptr_MinstrelHePerRemoteStation station){
    //set the max and 2nd max throughput rates of the groups and the station
    UINT i,j;
    BOOL isHe = station->isHe;
    UINT grpmaxThId,grpmaxTh2Id;
    double grpmaxTh,grpmaxThProb,grpmaxTh2,grpmaxTh2Prob,th,prob;
 
    UINT maxThId = He_GetLowestIndex(station);
    double maxTh = station->groupTable[HE_GetGroupId(maxThId,isHe)].rateTable[HE_GetRateId(maxThId,isHe)].throughput;
    double maxThProb = station->groupTable[HE_GetGroupId(maxThId,isHe)].rateTable[HE_GetRateId(maxThId,isHe)].ewmaProb;
 
 
    UINT maxTh2Id = He_GetLowestIndex(station);
    double maxTh2 = station->groupTable[HE_GetGroupId(maxTh2Id,isHe)].rateTable[HE_GetRateId(maxTh2Id,isHe)].throughput;    
    double maxTh2Prob = station->groupTable[HE_GetGroupId(maxTh2Id,isHe)].rateTable[HE_GetRateId(maxTh2Id,isHe)].ewmaProb;
    for(i=0;i<station->nGroup;i++){         //for each group
    if(!station->groupTable[i].supported)
        continue;
        
    grpmaxTh = 0;
    grpmaxThId = 0;     //will be rate id
    grpmaxThProb = 0;
        
    grpmaxTh2 = 0;
    grpmaxTh2Id = 0;
    grpmaxTh2Prob = 0;
    for(j=0;j<station->nGroupRate;j++){
        if(!station->groupTable[i].rateTable[j].supported)
        continue;
            
        th = station->groupTable[i].rateTable[j].throughput;
        prob = station->groupTable[i].rateTable[j].ewmaProb;
        //rate is better than current grp best
        if(th > grpmaxTh || (th == grpmaxTh && prob > grpmaxThProb)){
        grpmaxTh2 = grpmaxTh;
        grpmaxTh2Prob = grpmaxThProb;
        grpmaxTh2Id = grpmaxThId;
                
        grpmaxTh = th;
        grpmaxThProb = prob;
        grpmaxThId = j;
        }
        //rate is better than current grp 2nd best
        else if(th > grpmaxTh2 || (th == grpmaxTh2 && prob > grpmaxTh2Prob)){
        grpmaxTh2 = th;
        grpmaxTh2Prob = prob;
        grpmaxTh2Id = j;
        }
        //do nothing
        else{
        }
    }
 
    //compare grp values with station values
    if(grpmaxTh > maxTh || (grpmaxTh == maxTh && grpmaxThProb > maxThProb)){
        maxTh2 = maxTh;
        maxTh2Id = maxThId;
        maxTh2Prob = maxThProb;
 
        maxTh = grpmaxTh;
        maxThId = HE_GetIndex(i,grpmaxThId,station->isHe);
        maxThProb = grpmaxThProb;
    }
    else if(grpmaxTh > maxTh2 || (grpmaxTh == maxTh2 && grpmaxThProb > maxTh2Prob)){
        maxTh2 = grpmaxTh;
        maxTh2Prob = grpmaxThProb;
        maxTh2Id = HE_GetIndex(i,grpmaxThId,station->isHe);
    }
 
    if(grpmaxTh2 > maxTh2 || (grpmaxTh2 == maxTh2 && grpmaxTh2Prob > maxTh2Prob)){
        maxTh2 = grpmaxTh2;
        maxTh2Prob = grpmaxTh2Prob;
        maxTh2Id = HE_GetIndex(i,grpmaxTh2Id,station->isHe);
    }
    else{
    }
    }
 
    station->maxTpRate = maxThId;
    station->maxTpRate2 = maxTh2Id;
}
 
static void He_SetStationProbRate(Ptr_MinstrelHePerRemoteStation station){
    UINT i,j,grpmaxProbId;
    BOOL isHe = station->isHe;
    double th,prob,grpmaxProb,grpmaxProbTh;
 
    UINT maxProbId= He_GetLowestIndex(station);
    double maxProb= station->groupTable[HE_GetGroupId(maxProbId,isHe)].rateTable[HE_GetRateId(maxProbId,isHe)].ewmaProb;
    double maxProbTh= station->groupTable[HE_GetGroupId(maxProbId,isHe)].rateTable[HE_GetRateId(maxProbId,isHe)].throughput;
    for(i=0;i<station->nGroup;i++){
    if(!station->groupTable[i].supported)
        continue;
        
    grpmaxProb=0;
    grpmaxProbId=0; //will be rate id
    grpmaxProbTh=0; 
    for(j=0;j<station->nGroupRate;j++){
        if(!station->groupTable[i].rateTable[j].supported)
        continue;
 
        th = station->groupTable[i].rateTable[j].throughput;
        prob = station->groupTable[i].rateTable[j].ewmaProb;
        if(prob > 0.75){
        if(th > grpmaxProbTh){
            grpmaxProbTh = th;
            grpmaxProb = prob;
            grpmaxProbId = j;
        }
        }
        else{
        if(prob > grpmaxProb){
            grpmaxProbTh =th;
            grpmaxProb = prob;
            grpmaxProbId = j;
        }
        }
    }
 
    //update station values based on group values if necessary
    if(grpmaxProb > 0.75){
        if(grpmaxProbTh > maxProbTh){
        maxProbTh = grpmaxProbTh;
        maxProb = grpmaxProb;
        maxProbId = HE_GetIndex(i,grpmaxProbId,station->isHe);
        }
    }
    else{
        if(grpmaxProb > maxProb){
        maxProbTh = grpmaxProbTh;
        maxProb = grpmaxProb;
        maxProbId = HE_GetIndex(i,grpmaxProbId,station->isHe);              
        }
    }
    }
    station->maxProbRate = maxProbId;
 
}
 
static UINT He_GetNextSample(Ptr_MinstrelHePerRemoteStation station){
    UINT sampleGroup = station->sampleGroup;
    UINT row = station->groupTable[sampleGroup].row;
    UINT col = station->groupTable[sampleGroup].col;
    UINT sampleIndex = station->sampleTable[row][col];      //rateId
    UINT rateIndex = HE_GetIndex(sampleGroup, sampleIndex,station->isHe);   //fill
    He_SetNextSample(station);      //set the next sample rate
 
    return rateIndex;
}
 
static void He_SetNextSample(Ptr_MinstrelHePerRemoteStation station){
    //search for the next supported group
    do{
    station->sampleGroup = (++station->sampleGroup)%station->nGroup;
    }while(!station->groupTable[station->sampleGroup].supported);
 
    station->groupTable[station->sampleGroup].row++;
    if(station->groupTable[station->sampleGroup].row >= station->nGroupRate){
    station->groupTable[station->sampleGroup].row = 0;
    if(++station->groupTable[station->sampleGroup].col >= he_sampleCol)
        station->groupTable[station->sampleGroup].col = 0;
    }
}
 
static double He_CalculateEwmsd(double oldEwmsd, double currentProb, double ewmaProb, double ewmaWeight){
    double diff, incr, tmp;
 
    /* calculate exponential weighted moving variance */
    diff = currentProb - ewmaProb;
    incr = (ewmaWeight) * diff / 100;
    tmp = oldEwmsd * oldEwmsd;
    tmp = (100- ewmaWeight)* (tmp + diff * incr) / 100;
 
    /* return standard deviation */
    return sqrt (tmp);
}
 
static double He_CalculateThroughput(Ptr_MinstrelHePerRemoteStation station,UINT grpId, UINT rateId){
    if(station->groupTable[grpId].rateTable[rateId].ewmaProb < 0.1)
    return 0;
    else{
    double ewmaProb = station->groupTable[grpId].rateTable[rateId].ewmaProb;
    double rate = station->groupTable[grpId].rateTable[rateId].rate;
    double nPackets = station->avgAmpduLen;
    double TrTime = HE_firstTransmissionTime(station->phy,1500,rate) + HE_transmissionTime(station->phy,1500,rate)*(nPackets - 1);
    return (max(ewmaProb,0.9)*8*1500*nPackets)/TrTime;          //check and fill
    }
}
 
static void He_CalculateRetransmits(Ptr_MinstrelHePerRemoteStation station,UINT index){
    UINT grpId = HE_GetGroupId(index,station->isHe);
    UINT rateId = HE_GetRateId(index,station->isHe);
    UINT cw = 15;
    UINT cwMax = 1023;
    double cwTime,txTime,dataTxTime,rate;
 
 
    if(station->groupTable[grpId].rateTable[rateId].retryUpdated)
    return;
 
    if(station->groupTable[grpId].rateTable[rateId].ewmaProb < 0.01)
    station->groupTable[grpId].rateTable[rateId].retryCount =1;
    else{
    station->groupTable[grpId].rateTable[rateId].retryCount =2; 
    station->groupTable[grpId].rateTable[rateId].retryUpdated = true;
    
    rate = station->groupTable[grpId].rateTable[rateId].rate;
    //data transmission time
    dataTxTime = HE_firstTransmissionTime(station->phy,1500,rate) + HE_transmissionTime(station->phy,1500,rate) * (station->avgAmpduLen - 1);
 
    //contention time for first two transmission
    cwTime = (HE_tSlot(station->phy)*cw)>>1;
    cw = min((cw<<1)| 1,cwMax);
    cwTime += (HE_tSlot(station->phy)*cw)>>1;
    cw = min((cw<<1)| 1,cwMax);
 
    txTime = cwTime + 2*(dataTxTime + HE_ackTime(station->phy));
 
    do{
        cwTime = (HE_tSlot(station->phy)*cw)>>1;
        cw = min((cw<<1)| 1,cwMax);
        txTime += dataTxTime + HE_ackTime(station->phy) + cwTime;
    }while(txTime < 6000 && (++station->groupTable[grpId].rateTable[rateId].retryCount < 7));
    
    }
}
 
BOOL He_DoNeedDataRetransmission(NETSIM_ID devid,NETSIM_ID ifid,NETSIM_ID recvid){
    Ptr_MinstrelHePerRemoteStation station = He_getMinstrelInfo(devid,ifid,recvid);
    return (station->longRetry < He_CountRetries(station));
}
 
static UINT He_CountRetries(Ptr_MinstrelHePerRemoteStation station){    //fill
    //is station is sampling
    BOOL isHe = station->isHe;
    UINT th = station->maxTpRate;
    UINT th2 = station->maxTpRate2;
    UINT prob = station->maxProbRate;
    if(!station->isSampling){
    return station->groupTable[HE_GetGroupId(th,isHe)].rateTable[HE_GetRateId(th,isHe)].retryCount + station->groupTable[HE_GetGroupId(th2,isHe)].rateTable[HE_GetRateId(th2,isHe)].retryCount + station->groupTable[HE_GetGroupId(prob,isHe)].rateTable[HE_GetRateId(prob,isHe)].retryCount;
    }
    else{
        return 1 + station->groupTable[HE_GetGroupId(th2,isHe)].rateTable[HE_GetRateId(th2,isHe)].retryCount + station->groupTable[HE_GetGroupId(prob,isHe)].rateTable[HE_GetRateId(prob,isHe)].retryCount;
    }
}
 
static UINT He_GetLowestIndex(Ptr_MinstrelHePerRemoteStation station){
    UINT grpId = 0;
    UINT rateId = 0;
 
    while(!(int)grpId < (int)station->nGroup &&
    !station->groupTable[grpId].supported)
    grpId++;
 
    if(grpId == station->nGroup)
    fnNetSimError("No groups supported..!");
 
    while(rateId < station->nGroupRate && !station->groupTable[grpId].rateTable[rateId].supported)
    rateId++;
 
    if(rateId == station->nGroupRate)
    fnNetSimError("No rates supported...!");
 
    return HE_GetIndex(grpId,rateId,station->isHe);
}
 
static UINT He_GetHighestIndex(Ptr_MinstrelHePerRemoteStation station){
    int grpId = station->nGroup -1;
    int rateId = station->nGroupRate -1;
    while(grpId >= 0 && !station->groupTable[grpId].supported)
    grpId--;
 
    if(grpId == -1)
    fnNetSimError("No groups supported..!");
 
    while(rateId >= 0 && !station->groupTable[grpId].rateTable[rateId].supported)
    rateId--;
 
    if(rateId == -1)
    fnNetSimError("No rates supported..!");
 
    return HE_GetIndex(grpId,rateId,station->isHe);
}
 
struct stru_802_11_Phy_Parameters_HE He_getTxRate(NETSIM_ID devid,NETSIM_ID ifid,NETSIM_ID recvid)
{
    Ptr_MinstrelHePerRemoteStation station = He_getMinstrelInfo(devid,ifid,recvid);
    UINT grpId = HE_GetGroupId(station->trRate,station->isHe);
    UINT rateId = HE_GetRateId(station->trRate,station->isHe);
    UINT W = station->groupTable[grpId].chWidth;
    UINT S = station->groupTable[grpId].streams;
    UINT r;
    if(station->groupTable[grpId].sgi == 800){
    r = rateId;
    }
    else if (station->groupTable[grpId].sgi == 1600){
    r = 12 + rateId;
    }
    else {
        r = 24 + rateId;
    }
    return get_phy_parameter_HE(W,S)[r];
 
}
 
void HE_Minstrel_Free(NETSIM_ID nDevId, NETSIM_ID nifid)
{
#pragma message(__LOC__"Implement the HE_Minstrel_Free")
IEEE802_11_PHY(nDevId,nifid)->rateAdaptationData = NULL;
}