数据流量监测工具[视频会议][源玛共享]

　　最近视频会议的一个模块总是有点不对劲，从网络接收的数据到缓冲并转发到网络的过程中发现数据流不正常，为了便于调试并清楚到底有多少数据收到并以多少速率转发到网络，决定写一个可以监测数据流量的工具。感觉这个工具在查看多路多点位置的数据流非常好用。推荐一下，希望大家多提意见。不明白的，请多提问题哦。

NOTE：这段代码在cygwin下调试过，结果看最后。本人的真正开发环境是vxworks下，所以在下面的代码中也附带了vxworks的相应部分。

1. 单通道版本

#include <stdio.h>
#include <string.h>

/* 工具功能 : 测试流媒体数据流经模块内部
* 各个点的流量统计信息，用于软件问题的诊断调试
* 工具功能 :在需要监测的位置添加一段监测 代码(见DEMO)
* 然后调用PacketPrint() 并传入监测时间，过一段时间就可以看到结果。
* 工具DEMO :
* {
* static short nCallerID = INVALID_VALUE;
*
* PacketStat(__FUNCTION__,__LINE__,&nCallerID);
* }

*/

#define CYGWIN_ENVIRONMENT /*定义测试环境*/

#define INVALID_VALUE -1
#define MAX_CALLERS 30 /*流量统计监测点的最大数目*/
#define MAX_FUNC_NAME_LEN 100 /*监测点调用函数的函数名最大长度*/
#define MAX_MONITOR_SECONDS 99 /*流量统计时间,单位为秒*/
#define MAX_PACKET_NUM 60*(MAX_MONITOR_SECONDS+1)/*最大测试包数*/

#define TRUE 1
#define FALSE 0

typedef struct _TagCallerInfo
{
char pFuncName[MAX_FUNC_NAME_LEN]; /*调用函数的函数名，caller名称*/
char nFuncLen;/*调用函数的函数名实际长度*/
short nLine;/*调用函数的调用点位置*/

}TCallerInfo;

typedef struct _TagPacketInfo
{
int nPackets; /*监测点流经总包数*/
int nPacketRate; /*监测点流量*/
int nPrevPackets; /*该点上一次监测的累计包数*/
long nPrevTicks; /*该点上一次监测的累计时间*/
int nInterval; /*前后两次监测的时间跨度*/

}TPacketInfo;

static TCallerInfo g_tCaller[MAX_CALLERS];
static TPacketInfo g_tPacket[MAX_CALLERS];
static int g_nCallers = 0;

void PacketStat(char* pFuncName,short nLine,short* pCallerID);
void PacketPrint(int nInterval/*second*/);

void hello(void);
void world(void);
void delay(void);

#ifdef CYGWIN_ENVIRONMENT
int main(int argc, char *argv[])
{
int i;

hello();/*监测1，caller 为hello*/
world();/*监测2，caller 为world*/
}
#else/*vxworks*/
void usrAppInit (void)
{
#ifdef USER_APPL_INIT
USER_APPL_INIT;
#endif

/* add application specific code here */
hello();/*监测1，caller 为hello*/
world();/*监测2，caller 为world*/
}

#endif

void hello(void)
{
int i,j;

for (i = 0 ; i < MAX_PACKET_NUM; i++)
{
#ifdef CYGWIN_ENVIRONMENT/*cygwin 下测试代码*/
delay();
#else/*vxworks*/
taskDelay(3);/*模拟20 包每秒的速率*/
#endif

/*----- 包率监测点具体位置---*/
{
static short nCallerID = INVALID_VALUE;

PacketStat(__FUNCTION__,__LINE__,&nCallerID);
}
/*--------------------------------------*/
}
}

void world(void)
{
int i,j;

for (i = 0 ; i < MAX_PACKET_NUM; i++)
{
#ifdef CYGWIN_ENVIRONMENT/*cygwin 下测试代码*/
delay();
#else/*vxworks*/
taskDelay(3);/*模拟20 包每秒的速率*/
#endif

/*----- 包率监测点具体位置---*/
{
static short nCallerID = INVALID_VALUE;

PacketStat(__FUNCTION__,__LINE__,&nCallerID);
}
/*--------------------------------------*/
}
}

#ifdef CYGWIN_ENVIRONMENT
void delay(void)
{
int i=10000;

while(i-->0)/*延时10000 cycles，任意定义，可以是其它值*/
;
}
#endif

void PacketStat(char* pFuncName,short nLine,short* pCallerID)
{
int nCaller = 0;
long nCurrTicks = 0;
static int bInitialized = FALSE;
TCallerInfo* ptCaller = NULL;
TPacketInfo* ptPacket = NULL;

if (NULL == pFuncName || NULL == pCallerID)
{
printf("invalid function name and pos pointer!");
return;
}

if (!bInitialized)
{ /*第一次要初始化*/
memset(&g_tCaller[0],0,sizeof(TCallerInfo)*MAX_CALLERS);
memset(&g_tPacket[0],0,sizeof(TPacketInfo)*MAX_CALLERS);
bInitialized = TRUE;
}

if (INVALID_VALUE == *pCallerID)
{ /*如果是某监测点第一次调用该函数*/
nCaller = g_nCallers++;
ptCaller = &g_tCaller[nCaller];

ptCaller->nFuncLen = strlen(pFuncName);

if (ptCaller->nFuncLen>MAX_FUNC_NAME_LEN)
{
printf("too long function name!/n");
return;
}

ptCaller->nFuncLen = sprintf(ptCaller->pFuncName,"%s",pFuncName);

ptCaller->nLine = nLine;
*pCallerID = nCaller;/*返回当前监测点的ID，以备后用*/

#ifdef CYGWIN_ENVIRONMENT/*cygwin 下测试代码*/
PacketPrint(MAX_MONITOR_SECONDS);
#endif
}
else
{
nCaller = *pCallerID;
}

ptCaller = &g_tCaller[nCaller];
ptPacket = &g_tPacket[nCaller];

/*等待用户设置检测时间*/
if (ptPacket->nInterval <1)
{
return;
}

if (nCaller >= 0 && nCaller<MAX_CALLERS)
{
ptPacket->nPackets++;

#ifdef CYGWIN_ENVIRONMENT/*设置包率为1 个tick 一个包的情况,测试代码的正确性*/
nCurrTicks = ptPacket->nPackets;
#else
nCurrTicks = tickGet();
#endif
if (0 == ptPacket->nPrevTicks)
{
ptPacket->nPrevPackets = ptPacket->nPackets;
ptPacket->nPrevTicks = nCurrTicks;
}
else
{
if (nCurrTicks-ptPacket->nPrevTicks >= ptPacket->nInterval*60)
{
ptPacket->nPacketRate = 60*(ptPacket->nPackets - ptPacket->nPrevPackets)
/(nCurrTicks - ptPacket->nPrevTicks);

printf("%s %5d:packets %d,rate %d p/s/n",ptCaller->pFuncName,
ptCaller->nLine,ptPacket->nPackets,ptPacket->nPacketRate);

ptPacket->nPrevTicks = 0;
ptPacket->nInterval = 0;
}
}
}
}

void PacketPrint(int nInterval/*second*/)
{
int nCaller;

for (nCaller = 0; nCaller < g_nCallers; nCaller++)
{
g_tPacket[nCaller].nInterval = nInterval;
}
}




2. 多通道改进版本

#ifdef PACKET_RATE_MONITOR
#include <string.h>
#define MAX_CALLERS 30 /*流量统计监测点的最大数目*/
#define MAX_CHANNELS 64 /*每个监测点支持通道的最大数目*/

#define MAX_FUNC_NAME_LEN 30 /*监测点调用函数的函数名最大长度*/
#define MAX_HINT_INFO_LEN 80 /*监测点调用函数的函数名最大长度*/
#define MAX_MONITOR_SECONDS 99 /*流量统计时间,单位为秒*/
#define MAX_PACKET_NUM 60*(MAX_MONITOR_SECONDS+1)/*最大测试包数*/

typedef struct _TagCallerInfo
{
NW_CHAR pchFuncName[MAX_FUNC_NAME_LEN]; /*调用函数的函数名，caller名称*/
NW_CHAR nFuncLen;/*调用函数的函数名实际长度*/
NW_SHORT nLine;/*调用函数的调用点位置*/

}TCallerInfo;

typedef struct _TagPacketInfo
{
NW_INT32 nPackets[MAX_CHANNELS]; /*监测点流经总包数*/
NW_INT32 nPacketRate[MAX_CHANNELS]; /*监测点流量*/
NW_INT32 nPrevPackets[MAX_CHANNELS];/*该点上一次监测的累计包数*/
NW_INT32 nPrevTicks[MAX_CHANNELS]; /*该点上一次监测的累计时间*/
NW_INT32 nInterval[MAX_CHANNELS]; /*前后两次监测的时间跨度*/

}TPacketInfo;

static TCallerInfo g_tCaller[MAX_CALLERS];
static TPacketInfo g_tPacket[MAX_CALLERS];
static NW_INT32 g_nCallers = 0;

void PacketRatePrint(int nInterval/*second*/);

void PacketRateStat(NW_CHAR* pchFuncName,NW_SHORT nLine,NW_SHORT* pCallerID,NW_SHORT nChannelID)
{
NW_INT32 nCaller = 0;
NW_INT32 nCurrTicks = 0;
static NW_BOOL bInitialized = FALSE;
TCallerInfo* ptCaller = NULL;
TPacketInfo* ptPacket = NULL;

if (NULL == pchFuncName || NULL == pCallerID)
{
printf("invalid function name and pos pointer!");
return;
}

if (nChannelID < 0 || nChannelID >= MAX_CHANNELS)
{
printf("invalid channel id %d!",nChannelID);
return;
}

if (!bInitialized)
{ /*第一次要初始化*/
memset(&g_tCaller[0],0,sizeof(TCallerInfo)*MAX_CALLERS);
memset(&g_tPacket[0],0,sizeof(TPacketInfo)*MAX_CALLERS);
bInitialized = TRUE;
}

if (INVALID_VALUE == *pCallerID)
{ /*如果是某监测点第一次调用该函数*/
nCaller = g_nCallers++;
ptCaller = &g_tCaller[nCaller];

ptCaller->nFuncLen = strlen(pchFuncName);

if (ptCaller->nFuncLen>MAX_FUNC_NAME_LEN)
{
printf("too long function name!/n");
return;
}

ptCaller->nFuncLen = sprintf(ptCaller->pchFuncName,"%s",pchFuncName);
ptCaller->nLine = nLine;
*pCallerID = nCaller;/*返回当前监测点的ID，以备后用*/
}
else
{
nCaller = *pCallerID;
}

ptCaller = &g_tCaller[nCaller];
ptPacket = &g_tPacket[nCaller];

/*等待用户设置检测时间*/
if (ptPacket->nInterval[nChannelID] <1)
{
return;
}

if (nCaller >= 0 && nCaller<MAX_CALLERS)
{
ptPacket->nPackets[nChannelID]++;

nCurrTicks = tickGet();

if (0 == ptPacket->nPrevTicks[nChannelID])
{
ptPacket->nPrevPackets[nChannelID] = ptPacket->nPackets[nChannelID];
ptPacket->nPrevTicks[nChannelID] = nCurrTicks;
}
else
{
if (nCurrTicks-ptPacket->nPrevTicks[nChannelID] >= ptPacket->nInterval[nChannelID]*60)
{
ptPacket->nPacketRate[nChannelID] = 60*(ptPacket->nPackets[nChannelID] - ptPacket->nPrevPackets[nChannelID])
/(nCurrTicks - ptPacket->nPrevTicks[nChannelID]);

logMsg("%s %5d,channel %d:rate %d p/s,packets %d./n",ptCaller->pchFuncName,
ptCaller->nLine,nChannelID,ptPacket->nPacketRate[nChannelID],ptPacket->nPackets[nChannelID]);

ptPacket->nPrevTicks[nChannelID] = 0;
ptPacket->nInterval[nChannelID] = 0;
}
}
}
}

void PacketRatePrint(int nInterval/*second*/)
{
NW_INT32 nCaller;
NW_INT32 nChannel;

for (nCaller = 0; nCaller < g_nCallers; nCaller++)
{
for (nChannel = 0; nChannel < MAX_CHANNELS; nChannel++)
{
g_tPacket[nCaller].nInterval[nChannel] = nInterval;
}
}
}
#endif