networkstat.h

跨操作系统的微型中间件

#ifndef __NETWORK_STAT_H_F_4959rj49__
#define __NETWORK_STAT_H_F_4959rj49__


#ifdef WIN32
#pragma warning(disable:4786)
#endif

#include <list>
#include "OSHeaders.h"
#include "OSMutex.h"
#include "OS.h"

class CCurUsedBindwidthCalc;
extern CCurUsedBindwidthCalc	*g_pRstpBindwidthCalc;

using namespace std;
class CCurUsedBindwidthCalc
{
	struct SInputDataSize
	{
		UInt64	m_UpdateTime; //更新时间:ms
		UInt32	m_DataSize;	  //传输的字节数:Byte
	};
	
public:
	CCurUsedBindwidthCalc();
	~CCurUsedBindwidthCalc();
	
	void	InputDownDataSize(UInt32 nDownDataSize);
	void	InputUpDataSize(UInt32 nUpDataSize);
	
	UInt32	GetDownBindwidth();
	UInt32	GetUpBindwidth();
	
	UInt32	GetBiBindwidth();
	
	void	SetCalcWindow(UInt32 nWinSize); //单位:s
private:
	OSMutex					m_mtxDown;
	list<SInputDataSize>	m_DownList;
	UInt32					m_DownSumSize;
	
	OSMutex					m_mtxUp;
	list<SInputDataSize>	m_UpList;
	UInt32					m_UpSumSize;
	
	UInt32	m_CalcWindow;		//计算带宽的时间窗口大小: ms
};


class CLostPacketRateCalc
{
	struct SSendedAndRecvedPackets
	{
		UInt32	m_SendedCount;
		UInt32	m_RecvedCount;
	};
public:
	CLostPacketRateCalc();
	~CLostPacketRateCalc();
	
	CLostPacketRateCalc& operator=(CLostPacketRateCalc &src);

	void	RecordPackets(UInt32 nSendedCount, UInt32 nRecvedCount);

	//return: x/10000
	UInt32	GetLostRate();
	
	void	SetCalcWin(UInt32 nWinSize);
private:
	UInt32							m_CalcWindow;

	OSMutex							m_mtxRecordPackets;
	list<SSendedAndRecvedPackets>	m_lstRecordPackets;
	UInt32							m_SumSended;
	UInt32							m_SumRecved;
};


class CRTTDetector
{
};


template <class T>
class CStatisticCalc
{
private:
	struct _Item
	{
		Int64	Time;
		T	Value;
	};
	typedef list<_Item>	_List;
	typedef typename _List::iterator _ListIterator;
public:
	CStatisticCalc();
	~CStatisticCalc() {}

public:
	void	AddValue(T &value);
	T		GetSum(UInt32 &outCount);

	enum	WinMetric { NUMBER = 0, TIME = 1};
	void	SetWindow(Int64 vSize, WinMetric vMetric);

	void	Clear();

private:
	void	ClearOldItem();

private:
	UInt32			m_CalcWindow;
	OSMutex			m_Mutex;
	_List			m_lstRecords;
	WinMetric		m_Metric;
};


//////////////////////////////////////////////////////////////////////////
inline void CCurUsedBindwidthCalc::SetCalcWindow(UInt32 nWinSize)
{
	if(nWinSize < 1) nWinSize = 1;
	if(nWinSize > 60) nWinSize = 60;
	m_CalcWindow = nWinSize;
}

inline UInt32 CCurUsedBindwidthCalc::GetBiBindwidth()
{
	return GetDownBindwidth() + GetUpBindwidth();
}



//////////////////////////////////////////////////////////////////////////
inline void CLostPacketRateCalc::SetCalcWin(UInt32 nWinSize)
{
	m_CalcWindow = nWinSize;
}

template <class T>
CStatisticCalc<T>::CStatisticCalc()
{
	m_CalcWindow = 3000;	//3s
	m_Metric = TIME;
}

template <class T>
void CStatisticCalc<T>::AddValue(T &value)
{
	m_Mutex.Lock();
	_Item item;
	if(m_Metric == TIME)
		item.Time = OS::Milliseconds();
	else
		item.Time = 0;
	item.Value = value;
	m_lstRecords.push_back(item);

	ClearOldItem();

	m_Mutex.Unlock();
}

template <class T>
T CStatisticCalc<T>::GetSum(UInt32 &outCount)
{
	m_Mutex.Lock();
	
	ClearOldItem();
	
	T Ret;
	outCount = 0;
	Bool isFirst = TRUE;
	_ListIterator it;
	for(it = m_lstRecords.begin(); it != m_lstRecords.end(); ++it)
	{
		if(!isFirst)
		{
			Ret = Ret + (*it).Value;
		}
		else
		{
			Ret = (*it).Value;
			isFirst = FALSE;
		}

		outCount++;
	}
	m_Mutex.Unlock();

	return Ret;
}

template <class T>
void CStatisticCalc<T>::SetWindow(Int64 vSize, WinMetric vMetric)
{
	if(vSize > 0)
		m_CalcWindow = vSize;

	m_Metric = vMetric;
}

template <class T>
void CStatisticCalc<T>::ClearOldItem()
{
	if(m_Metric == TIME)
	{
		Int64 iTimeOutPoint = OS::Milliseconds() - m_CalcWindow;
		_Item *pItem = NULL;
		while(!m_lstRecords.empty())
		{
			pItem = &m_lstRecords.front();
			if(pItem->Time < iTimeOutPoint)
				m_lstRecords.pop_front();
			else
				break;
		}
	}
	else if(m_Metric == NUMBER)
	{
		while(m_lstRecords.size() > m_CalcWindow)
			m_lstRecords.pop_front();
	}
}

template <class T>
void CStatisticCalc<T>::Clear()
{
	m_Mutex.Lock();
	m_lstRecords.clear();
	m_Mutex.Unlock();
}

#endif