bandwidthmanager.cpp

模拟P2P各种网络环境的,适合新手们的学习,不错的源码.

#include "BandwidthManager.h"
#include "Connection.h"

BandwidthManager::BandwidthManager(): mBandwidth(0), mBandwidthIn(0), mBandwidthOut(0),  mAvailableBandwidthIn(0), mAvailableBandwidthOut(0)
{ }

BandwidthManager::~BandwidthManager()
{ }
	
void BandwidthManager::setBandwidth(unsigned long bandwidth)
{
	mBandwidth = bandwidth;
	mBandwidthIn = bandwidth / 2;
	mBandwidthOut = bandwidth / 2;
	mAvailableBandwidthIn = bandwidth / 2;
	mAvailableBandwidthOut = bandwidth / 2;
}

void BandwidthManager::setBandwidth(bool flag, unsigned long bandwidth)
{
	mBandwidth += bandwidth;
	if(flag) {
		mBandwidthIn = bandwidth;
		mAvailableBandwidthIn = bandwidth;
	}
	else {
		mBandwidthOut = bandwidth;
		mAvailableBandwidthOut = bandwidth;
	}
}

unsigned long BandwidthManager::getBandwidth() const
{ return mBandwidth; }

unsigned long BandwidthManager::getBandwidth(bool flag) const
{
	if(flag)
		return mBandwidthIn;
	else
		return mBandwidthOut;
}
	
unsigned long BandwidthManager::getAvailableBandwidth(bool flag) const
{
	if(flag)
		return mAvailableBandwidthIn;
	else
		return mAvailableBandwidthOut;
}

unsigned long BandwidthManager::getAverageBandwidthA(bool flag) const
{
	if(flag)
		return mBandwidthIn / mActiveConnectionSetIn.size();
	else
		return mBandwidthOut / mActiveConnectionSetOut.size();
}

unsigned long BandwidthManager::getAverageBandwidthB(bool flag) const
{
	if(flag)
		return mBandwidthIn / (mActiveConnectionSetIn.size() + 1);
	else
		return mBandwidthOut / (mActiveConnectionSetOut.size() + 1);
}

int BandwidthManager::getActiveNumber(bool flag) const
{
	if(flag)
		return mActiveConnectionSetIn.size();
	else
		return mActiveConnectionSetOut.size();
}

int BandwidthManager::getInactiveNumber(bool flag) const
{
	if(flag)
		return mInactiveConnectionSetIn.size();
	else
		return mInactiveConnectionSetOut.size();
}
	
set<Connection *> BandwidthManager::getActiveConnectionSet(bool flag) const
{
	if(flag)
		return mActiveConnectionSetIn;
	else
		return mActiveConnectionSetOut;
}

set<Connection *> BandwidthManager::getInactiveConnectionSet(bool flag) const
{
	if(flag)
		return mInactiveConnectionSetIn;
	else
		return mInactiveConnectionSetOut;
}
		
void BandwidthManager::addConnection(bool flag, Connection *pc)
{
	if(!pc)
		exit(-1);
	if(flag) {
		if(mInactiveConnectionSetIn.find(pc) != mInactiveConnectionSetIn.end())
			{ cout << "in inactive (in) connection set in addConnection()" << endl; exit(-1); }
		if(mActiveConnectionSetIn.find(pc) != mActiveConnectionSetIn.end())
			{ cout << "in active (in) connection set in addConnection()" << endl; exit(-1); }
		mInactiveConnectionSetIn.insert(pc);
	}
	else {
		if(mInactiveConnectionSetOut.find(pc) != mInactiveConnectionSetOut.end())
			{ cout << "in inactive (out) connection set in addConnection()" << endl; exit(-1); }
		if(mActiveConnectionSetOut.find(pc) != mActiveConnectionSetOut.end())
			{ cout << "in active (out) connection set in addConnection()" << endl; exit(-1); }
		mInactiveConnectionSetOut.insert(pc);
	}
}


void BandwidthManager::removeConnection(bool flag, Connection *pc)
{
	if(!pc)
		exit(-1);
	if(flag) {
		if(mInactiveConnectionSetIn.find(pc) == mInactiveConnectionSetIn.end())
			{ cout << "not in inactive (in) connection set in removeConnection()" << endl; exit(-1); }
		if(mActiveConnectionSetIn.find(pc) != mActiveConnectionSetIn.end())
			{ cout << "in active (in) connection set in removeConnection()" << endl; exit(-1); }
		mInactiveConnectionSetIn.erase(pc);
	}
	else {
		if(mInactiveConnectionSetOut.find(pc) == mInactiveConnectionSetOut.end())
			{ cout << "not in inactive (out) connection set in removeConnection()" << endl; exit(-1); }
		if(mActiveConnectionSetOut.find(pc) != mActiveConnectionSetOut.end())
			{ cout << "in active (out) connection set in removeConnection()" << endl; exit(-1); }
		mInactiveConnectionSetOut.erase(pc);
	}
}

void BandwidthManager::activateConnection(bool flag, Connection *pc)
{
	if(!pc)
		exit(-1);
	if(flag) {
		mInactiveConnectionSetIn.erase(pc);
		mActiveConnectionSetIn.insert(pc);
		mAvailableBandwidthIn -= pc->getBandwidth();
		if(mAvailableBandwidthIn > mBandwidthIn)
			{ cout << "negative available (in) bandwidth in activateConnection()" << endl; exit(-1); }
	}
	else {
		mInactiveConnectionSetOut.erase(pc);
		mActiveConnectionSetOut.insert(pc);
		mAvailableBandwidthOut -= pc->getBandwidth();
		if(mAvailableBandwidthOut > mBandwidthOut)
			{ cout << "negative available (out) bandwidth in activateConnection()" << endl; exit(-1); }
	}
}

void BandwidthManager::inactivateConnection(bool flag, Connection *pc)
{
	if(!pc)
		exit(-1);
	if(flag) {
		mActiveConnectionSetIn.erase(pc);
		mInactiveConnectionSetIn.insert(pc);
		mAvailableBandwidthIn += pc->getBandwidth();
		if(mAvailableBandwidthIn > mBandwidthIn)
			{ cout << "greater available (in) bandwidth in inactivateConnection()" << endl; exit(-1); }
	}
	else {
		mActiveConnectionSetOut.erase(pc);
		mInactiveConnectionSetOut.insert(pc);
		mAvailableBandwidthOut += pc->getBandwidth();
		if(mAvailableBandwidthOut > mBandwidthOut)
			{ cout << "greater available (out) bandwidth in inactivateConnection()" << endl; exit(-1); }
	}
}

void BandwidthManager::adjustUp(bool flag, Connection *pc, unsigned long value)
{
	if(!pc)
		exit(-1);
	if(flag) {
		if(mActiveConnectionSetIn.find(pc) == mActiveConnectionSetIn.end())
			{ cout << "not in active (in) connection set in adjustUp()" << endl; exit(-1); }
		mAvailableBandwidthIn -= value;
		if(mAvailableBandwidthIn > mBandwidthIn)
			{ cout << "negative available (in) bandwidth in adjustUp()" << endl; exit(-1); }
	}
	else {
		if(mActiveConnectionSetOut.find(pc) == mActiveConnectionSetOut.end())
			{ cout << "not in active (out) connection set in adjustUp()" << endl; exit(-1); }
		mAvailableBandwidthOut -= value;
		if(mAvailableBandwidthOut > mBandwidthOut)
			{ cout << "negative available (out) bandwidth in adjustUp()" << endl; exit(-1); }
	}
}

void BandwidthManager::adjustDown(bool flag, Connection *pc, unsigned long value)
{
	if(!pc)
		exit(-1);
	if(flag) {
		if(mActiveConnectionSetIn.find(pc) == mActiveConnectionSetIn.end())
			{ cout << "not in active (in) connection set in adjustDown()" << endl; exit(-1); }
		mAvailableBandwidthIn += value;
		if(mAvailableBandwidthIn > mBandwidthIn)
			{ cout << "greater available (in) bandwidth in adjustDown()" << endl; exit(-1); }
	}
	else {
		if(mActiveConnectionSetOut.find(pc) == mActiveConnectionSetOut.end())
			{ cout << "not in active (out) connection set in adjustDown()" << endl; exit(-1); }
		mAvailableBandwidthOut += value;
		if(mAvailableBandwidthOut > mBandwidthOut)
			{ cout << "greater available (out) bandwidth in adjustDown()" << endl; exit(-1); }
	}
}
	
void BandwidthManager::reset()
{
	mAvailableBandwidthIn = mBandwidthIn;
	mAvailableBandwidthOut = mBandwidthOut;
	mActiveConnectionSetIn.clear();
	mActiveConnectionSetOut.clear();
	mInactiveConnectionSetIn.clear();
	mInactiveConnectionSetOut.clear();
}

void BandwidthManager::reallocate()
{
	unsigned long average;
	set<Connection *> leftConnection;
	set<Connection *>::iterator it;
	
	if(!mActiveConnectionSetIn.empty())
		average = getAverageBandwidthA(true);
	else
		average = mBandwidthIn;
	leftConnection = mActiveConnectionSetIn;
	while(!leftConnection.empty() && mAvailableBandwidthIn)
	{
		unsigned long min = UINT_MAX;
		Connection *pc = NULL;
		for(it = leftConnection.begin(); it != leftConnection.end(); it++)
		{
			unsigned long temp = (*it)->getBandwidth();
			if(min > temp) {
				min = temp;
				pc = *it;
			}
		}
		if(!pc)
			{ cout << "null pointer in reallocate()" << endl; exit(-1); }
		if(min < average)
			pc->adjustBandwidth(average - min, true);
		else
			pc->adjustBandwidth(mAvailableBandwidthIn, true);
	
		if(mAvailableBandwidthIn > mBandwidthIn)
			{ cout << "negative available (in) bandwidth in reallocate()" << endl; exit(-1); }
		leftConnection.erase(pc);
	}

	if(!mActiveConnectionSetOut.empty())
		average = getAverageBandwidthA(false);
	else
		average = mBandwidthOut;
	leftConnection = mActiveConnectionSetOut;
	while(!leftConnection.empty() && mAvailableBandwidthOut)
	{
		unsigned long min = UINT_MAX;
		Connection *pc = NULL;
		for(it = leftConnection.begin(); it != leftConnection.end(); it++)
		{
			unsigned long temp = (*it)->getBandwidth();
			if(min > temp) {
				min = temp;
				pc = *it;
			}
		}		
		if(!pc)
			{ cout << "null pointer in reallocate()" << endl; exit(-1); }
		if(min < average)
			pc->adjustBandwidth(average - min, true);
		else
			pc->adjustBandwidth(mAvailableBandwidthOut, true);
		
		if(mAvailableBandwidthOut > mBandwidthOut)
			{ cout << "negative available (out) bandwidth in reallocate()" << endl; exit(-1); }
		leftConnection.erase(pc);
	}
}
	
Connection *BandwidthManager::getMinConnection(bool flag)
{
	unsigned long min = UINT_MAX;
	Connection *pc = NULL;
	set<Connection *>::iterator it;
	if(flag)
		for(it = mActiveConnectionSetIn.begin(); it != mActiveConnectionSetIn.end(); it++) {
			unsigned long temp = (*it)->getBandwidth();
			if(min > temp) {
				min = temp;
				pc = *it;
			}
		}
	else
		for(it = mActiveConnectionSetOut.begin(); it != mActiveConnectionSetOut.end(); it++) {
			unsigned long temp = (*it)->getBandwidth();
			if(min > temp) {
				min = temp;
				pc = *it;
			}
		}
	return pc;
}

Connection *BandwidthManager::getMaxConnection(bool flag)
{
	unsigned long max = 0;
	Connection *pc = NULL;
	set<Connection *>::iterator it;
	if(flag)
		for(it = mActiveConnectionSetIn.begin(); it != mActiveConnectionSetIn.end(); it++) {
			unsigned long temp = (*it)->getBandwidth();
			if(max < temp) {
				max = temp;
				pc = *it;
			}
		}
	else
		for(it = mActiveConnectionSetOut.begin(); it != mActiveConnectionSetOut.end(); it++) {
			unsigned long temp = (*it)->getBandwidth();
			if(max < temp) {
				max = temp;
				pc = *it;
			}
		}
	return pc;	
}