void AdjustBuildIndex(int childi) {
   int targetindex = rebuild ? childi+1 : childi;
   if (targetindex > buildindex) {
     buildindex = targetindex;
     for (UserSet::iterator u = users.begin(); u != users.end(); ++u) {
       (*u)->AdjustBuildIndex(buildindex);
     }
   }
 }
예제 #2
0
	std::string ToString(SerializeFormat format) const
	{
		std::ostringstream oss;
		oss << lastnotify;
		for (UserSet::const_iterator i = accepting.begin(); i != accepting.end(); ++i)
		{
			User* u = *i;
			// Encode UIDs.
			oss << "," << (format == FORMAT_USER ? u->nick : u->uuid);
		}
		return oss.str();
	}
std::priority_queue<ProportionalFair::UserPreference>
ProportionalFair::calculateUserPreferences(UserSet activeUsers, bool txStrategy) const
{
    std::map<UserID, ChannelQualityOnOneSubChannel> sinrs;

    // preference for every user in a priority queue which automatically sorts
    std::priority_queue<UserPreference> preferences;
    assure(preferences.size()==0, "preferences.size() must be 0");

    for ( UserSet::const_iterator iter = activeUsers.begin();
          iter != activeUsers.end(); ++iter)
    {
        UserID user = *iter;
        assure(user.isValid(), "No valid user");

        //determines the users SINRs depending on the tx/Rx mode of the strategy
        if (txStrategy)
        {
            sinrs[user] = colleagues.registry->estimateTxSINRAt(user);
        }
        else
        {
            sinrs[user] = colleagues.registry->estimateRxSINROf(user);
        }

        // calculate PhyModeRate for available users
        wns::Ratio sinr(sinrs[user].carrier / sinrs[user].interference);
        wns::service::phy::phymode::PhyModeInterfacePtr phyMode = colleagues.registry->getPhyModeMapper()->getBestPhyMode(sinr);
        assure(phyMode->isValid(),"invalid PhyMode");

        // calculate userRate, which is the maximum possible data rate
        // for one subChannel for the best PhyMode available here
        float phyModeRate = phyMode->getDataRate(); // rate [b/s] of one subChannel
        float referenceRate;
        float pastDataRate = 1.0;

        // get the past data rate for this user:
        // iterate over the global past data rates map of all users and
        // find the past data rate for this user
        // there is exactly one pastDataRate value per userID
        int weight = colleagues.registry->getTotalNumberOfUsers(user);
        for (std::map<UserID, float>::const_iterator iter = pastDataRates.begin();
             iter != pastDataRates.end(); ++iter)
        {
            if (iter->first/*userID*/ == user)
            {
                float dataRate = iter->second;
                // a RN must get a better share of the bandwidth
                // here: proportional to its number of users:
                assure(weight>0, "numberOfUsers(" <<user.getName()<<")=" << weight);
                dataRate /= static_cast<float>(weight);
                // dataRate now has the meaning of a weight.
                pastDataRate = dataRate;
            }
        } // for all userIDs in pastDataRates

        if (pastDataRate < 0.01)
            pastDataRate = 0.01;

        // preference is achievable current user rate divided by a history
        // factor that takes the past throughput of this user into account

        assure(maxRateOfSubchannel>0.0, "unknown maxRateOfSubchannel");

        // goal is either rate (true) or resource (false) fairness
        if (rateFairness == true)
        {
            referenceRate = maxRateOfSubchannel;
        }
        else
        {
            referenceRate = phyModeRate;
        }

        // maxRateOfSubchannel is constant, with range [0..1][bit/s]
        float resultMaxThroughput = referenceRate / maxRateOfSubchannel;
        float resultPropFair      = referenceRate / pastDataRate; // can be any range
        if (scalingBetweenMaxTPandPFair <= 0.5) {
            // variate the preference for each user, so that they differ a little bit (1%)
            // and the automatic sorting does not always give the same order
            // (would be a problem for identical preference weights).
            resultMaxThroughput *=  (1 + 0.01*(*preferenceVariationDistribution)());
        }
        float UserPref =
            (1.0-scalingBetweenMaxTPandPFair) * resultMaxThroughput
            +scalingBetweenMaxTPandPFair  * resultPropFair;

        MESSAGE_SINGLE(NORMAL, logger, "getPreference("<<user.getName()<<"): weight=" << weight << ", pastDataRate= "<<pastDataRate<<" bit/s, UserPreference= "<<UserPref<<" (resultMaxThroughput="<<resultMaxThroughput<<",resultProportionalFair="<<resultPropFair<<")");

        // calculate preferences for users and order them
        preferences.push(UserPreference(UserPref, user));
    }
    return preferences;
}
/**
 * @brief Return a vector of users but only include those that could get an SINR
 * that is suitable for transmission when served alone. If we can't even
 * transmit when the users is grouped alone, there is no point in trying to
 * group him with users.
 */
std::vector<UserID>
AllPossibleGroupsGrouper::getServableUserVectorFromSet(const UserSet userSet, ModeType mode) {
	std::map<UserID, wns::CandI> candis;
	std::vector<UserID> userVector;

	// convert UserSet to userVector needed for calculateAllPossibleGroups
	for (UserSet::const_iterator iter = userSet.begin();
	     iter != userSet.end(); ++iter)
	{
		switch(mode) {
		case tx:
		{
			if (beamforming){
                std::map<wns::node::Interface*, wns::Power> userNoiseIInterMap;
				userNoiseIInterMap.clear();
				userNoiseIInterMap[iter->getNode()] = colleagues.registry->estimateTxSINRAt(*iter).interference;
				candis = convertMap(friends.ofdmaProvider->calculateCandIsTx(userNoiseIInterMap, x_friendliness, txPower));
			}
			else{ // no beamforming
				assure(userSet.size() == 1, "We don't do beamforming, so only one-user groups are supported");
				UserID user = *iter;
                wns::scheduler::ChannelQualityOnOneSubChannel cqi =
                    colleagues.registry->estimateTxSINRAt(user);
				candis[user] = wns::CandI(cqi.carrier, cqi.interference);
			}
		}
		break;
		case rx:
		{
			if (beamforming){
                std::vector<wns::node::Interface*> combination;
				combination.clear();
                combination.push_back(iter->getNode());

				candis = convertMap(friends.ofdmaProvider->calculateCandIsRx(combination,
                    colleagues.registry->estimateRxSINROf(*iter).interference));
			}
			else{ // no beamforming

				assure(userSet.size() == 1, "We don't do beamforming, so only one-user groups are supported");
				UserID user = *iter;
                wns::scheduler::ChannelQualityOnOneSubChannel cqi =
                    colleagues.registry->estimateRxSINROf(user);
				candis[user] = wns::CandI(cqi.carrier, cqi.interference);
			}

		}
		break;
		default:
			assure(0, "Unknown mode");
		}
		wns::Ratio sinr(candis[*iter].C / candis[*iter].I);
		//if (colleagues.registry->getPhyModeForSIR(candis[*iter].C / candis[*iter].I).second > 0.0001)
		if (colleagues.phyModeMapper->sinrIsAboveLimit(sinr))
			userVector.push_back(*iter);
		else {
			MESSAGE_BEGIN(VERBOSE, logger, m, colleagues.registry->getNameForUser(colleagues.registry->getMyUserID()));
			m << "removing user"
			  << colleagues.registry->getNameForUser(*iter)
			  << " because SINR is not sufficient even for serving the user alone";
			MESSAGE_END();

		}
	}
	return userVector;
}