tcpperftest.cpp

EP9315开发板的Wince6.0的BSP包文件

/**********************************************************************
#                                                                      
# Filename: TcpPerfTest.cpp
#                                                                      
# Description:
#
# THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
# ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
# PARTICULAR PURPOSE.
#
# Use of this source code is subject to the terms of the Cirrus end-user
# license agreement (EULA) under which you licensed this SOFTWARE PRODUCT.
# If you did not accept the terms of the EULA, you are not authorized to 
# use this source code. For a copy of the EULA, please see the 
# EULA.RTF on your install media.
#
# Copyright(c) Cirrus Logic Corporation 2007, All Rights Reserved                       
#                                                                      
#**********************************************************************/
// TcpPerfTest.cpp : Defines the entry point for the console application.
//
#include <windows.h>
#include <stdio.h>
#include <winsock2.h>
#include <ws2tcpip.h>


#define DEFAULT_FAMILY        AF_UNSPEC
#define DEFAULT_SOCKTYPE      SOCK_STREAM
#define DEFAULT_PORT          "1234"  //TCP Port number
#define BUFFER_SIZE           65536  //64K. The size of one block of data            
#define NUM_OF_BLOCKS_TO_TEST 1600 //number of blocks to be transmitted 
                                 //in the tests of Tx and Rx 
#define PINGPONG_FRAME_SIZE   1448 //1448 bytes. The size of the frame used in Ping-pong test.
#define PINGPONG_LOOP_COUNT   16000 //The loop count of the ping-pong test.

#define TIMEOUT_SECS        2
#define TIMEOUT_USECS       0

char pBuf[BUFFER_SIZE];
char server_addr[20]; //Server's IP address. Format: 123.111.222.333
SOCKET sock = INVALID_SOCKET;
ADDRINFO *AI;


//*****************************************************************************
//*
//*  print_usage()
//*
//*****************************************************************************
void print_usage(void)
{
    printf("[Usage]:\r\n");
    printf("TcpPerfTest  IP_Addr_of_Server\r\n\r\n");
    printf("IP_Addr Format: xxx.xxx.xxx.xxx\r\n");
    printf("\r\n");
}

//*****************************************************************************
//*
//*  parse_arguments()
//*
//*****************************************************************************
int parse_arguments(int argc, char *argv[]) 
{
    int status=0;
	int len;

	if (argc < 2)
	{
		return -1;
	}

/*
	printf(" argc=%d, \r\n", argc);
	for (i=0; i<argc; i++)
	{
      printf("argv[%d]=%s \r\n", i, argv[i]);
	}
	printf("\r\n");
*/

	len=strlen(argv[1]);
	if ( (len < 7) || (len > 16) )
	{
            //
            // Tell the user that the IP Address is invalid.
            //
            printf("Error:  Invalid IP Address '%s'.\n\n", argv[1]);

            //
            // We're done.
            //
            return(-1);
	}

    //
    // Get the IP address from the command line.
    //
    memcpy(server_addr, argv[1], len);
            

	return status;
} //end of parse_arguments()


//*****************************************************************************
//*
//*  Do_Rx_Perf_Test()
//*
//*****************************************************************************
int Do_Rx_Perf_Test(void)
{
	unsigned long blocksLeft=NUM_OF_BLOCKS_TO_TEST;
	unsigned long totalBytes=0;
	unsigned long i;
	unsigned long starttime, endtime;
	unsigned long timeDiff;
	double MBitPerSec, timeDiffSec, TotalBit;
    int cbXfer, cbTotalRecvd, cbRemoteAddrSize;
    SOCKADDR_STORAGE ssRemoteAddr;
	unsigned long dontcnt=NUM_OF_BLOCKS_TO_TEST/4;
	int status=-1;
	unsigned long startIdleTime, endIdleTime, idleDiff;
	double idleDiffSec, cpuUsage;


	printf("\r\nDoing TCP Rx Performance Test.... Block size=%d\r\n", BUFFER_SIZE);


	cbRemoteAddrSize = sizeof(ssRemoteAddr);


	for (i=1; i<dontcnt; i++)
	{
        cbTotalRecvd = 0;
        do
		{
          cbXfer = recvfrom(sock, pBuf+cbTotalRecvd, BUFFER_SIZE-cbTotalRecvd, 0, 
            (SOCKADDR *)&ssRemoteAddr, &cbRemoteAddrSize);
		  if(cbXfer == SOCKET_ERROR)
		  {
            printf("ERROR: S2 recvfrom() Error=%d cbXfer=%d\r\n", WSAGetLastError(), cbXfer);
		   break;
		  }   
          cbTotalRecvd += cbXfer;
		} while(cbXfer > 0 && cbTotalRecvd<BUFFER_SIZE);

        if(cbTotalRecvd != BUFFER_SIZE)
		{
          printf("ERROR: S5 cbTotalRecvd=%d\r\n", cbTotalRecvd);
          break;
		} 
	
	    blocksLeft--;
	} //end for

    totalBytes=0;
	starttime = GetTickCount( );
	startIdleTime=GetIdleTime();
	while ( blocksLeft > dontcnt)
	{
        cbTotalRecvd = 0;
        do
		{
          cbXfer = recvfrom(sock, pBuf+cbTotalRecvd, BUFFER_SIZE-cbTotalRecvd, 0, 
            (SOCKADDR *)&ssRemoteAddr, &cbRemoteAddrSize);
		  if(cbXfer == SOCKET_ERROR)
		  {
            printf("ERROR: S3 recvfrom() Error=%d cbXfer=%d\r\n", WSAGetLastError(), cbXfer);
		   break;
		  }   
          cbTotalRecvd += cbXfer;
		} while(cbXfer > 0 && cbTotalRecvd<BUFFER_SIZE);

        if(cbTotalRecvd != BUFFER_SIZE)
		{
          printf("ERROR: S5 cbTotalRecvd=%d\r\n", cbTotalRecvd);
          break;
		} else {
			totalBytes += cbTotalRecvd;
		}

	  blocksLeft--;
	}
	endtime = GetTickCount( );
	endIdleTime=GetIdleTime();


	while ( blocksLeft > 0)
	{
        cbTotalRecvd = 0;
        do
		{
          cbXfer = recvfrom(sock, pBuf+cbTotalRecvd, BUFFER_SIZE-cbTotalRecvd, 0, 
            (SOCKADDR *)&ssRemoteAddr, &cbRemoteAddrSize);
		  if(cbXfer == SOCKET_ERROR)
		  {
            printf("ERROR: S4 recvfrom() Error=%d cbXfer=%d\r\n", WSAGetLastError(), cbXfer);
		   break;
		  }   
          cbTotalRecvd += cbXfer;
		} while(cbXfer > 0 && cbTotalRecvd<BUFFER_SIZE);

        if(cbTotalRecvd != BUFFER_SIZE)
		{
          printf("ERROR: S5 cbTotalRecvd=%d\r\n", cbTotalRecvd);
          break;
		} 
	
	    blocksLeft--;
	} //end for

/*
    if(nSockType == SOCK_STREAM)
    {
        memset(&ssRemoteAddr, 0, sizeof(ssRemoteAddr));
        cbRemoteAddrSize = sizeof(ssRemoteAddr);
        getpeername(sock, (SOCKADDR *)&ssRemoteAddr, &cbRemoteAddrSize);
    }

    if (getnameinfo((SOCKADDR *)&ssRemoteAddr, cbRemoteAddrSize,
        szRemoteAddrString, sizeof(szRemoteAddrString), NULL, 0, NI_NUMERICHOST) != 0)
        strcpy(szRemoteAddrString, "");
*/
	status=0;

	timeDiff=endtime-starttime;
	timeDiffSec = timeDiff/1000.0;
	TotalBit= totalBytes*8.0;
	MBitPerSec = (TotalBit/timeDiffSec)/1048576.0;

	idleDiff=endIdleTime - startIdleTime;
	idleDiffSec = idleDiff/1000.0;
	cpuUsage=((timeDiffSec*100.0)-(idleDiffSec*100.0))/timeDiffSec;

	printf("\r\n**************** Receive Performance Test ********************\r\n");
	printf("starttime=%u msec, endtime=%u msec\r\n", starttime, endtime);
    printf("Time in msec = %u  Time in sec= %8.3f\r\n", timeDiff, timeDiffSec);
//    printf("SUCCESS - Received %u bytes back from address %hs\r\n", totalBytes, szRemoteAddrString);
    printf("SUCCESS - Received %u bytes back from address %hs\r\n", totalBytes, server_addr);
	printf("MBitPerSec = %8.3f MBitPerSec \r\n\r\n", MBitPerSec);

    printf("startIdleTime=%u, endIdleTime=%u, idleDiffSec=%5.3f \r\n", startIdleTime, endIdleTime, idleDiffSec);
	printf("CPU Usage=%5.2f%% \r\n", cpuUsage);
	printf("\r\n*************** End of Receive Performance Test *****************\r\n");


	return(status);
}

//*****************************************************************************
//*
//*  Do_Tx_Perf_Test()
//*
//*****************************************************************************
int Do_Tx_Perf_Test(void)
{
	unsigned long blocksLeft=NUM_OF_BLOCKS_TO_TEST;
	unsigned long totalBytes=0;
	unsigned long i;
	unsigned long starttime, endtime;
	unsigned long timeDiff;
	double MBitPerSec, timeDiffSec, TotalBit;
    int cbXfer, cbTotalTx, cbRemoteAddrSize;
    SOCKADDR_STORAGE ssRemoteAddr;
	unsigned long dontcnt=NUM_OF_BLOCKS_TO_TEST/4;
	int status=-1;
	unsigned long startIdleTime, endIdleTime, idleDiff;
	double idleDiffSec, cpuUsage;

	printf("\r\nDoing TCP Tx Performance Test.... Block size=%d\r\n", BUFFER_SIZE );

	cbRemoteAddrSize = sizeof(ssRemoteAddr);

	for (i=1; i<dontcnt; i++)
	{
        cbTotalTx = 0;
        do
		{
          cbXfer = sendto(sock, pBuf+cbTotalTx, BUFFER_SIZE-cbTotalTx, 0, 
            AI->ai_addr, AI->ai_addrlen);
		  if(cbXfer == SOCKET_ERROR)
		  {
            printf("ERROR: S2 sendto() Error=%d cbXfer=%d\r\n", WSAGetLastError(), cbXfer);
		   break;
		  }   
          cbTotalTx += cbXfer;
		} while(cbXfer > 0 && cbTotalTx<BUFFER_SIZE);

        if(cbTotalTx != BUFFER_SIZE)
		{
          printf("ERROR: S6 cbTotalTx=%d\r\n", cbTotalTx);
          break;
		} 
	
	    blocksLeft--;
	} //end for

    totalBytes=0;
	starttime = GetTickCount( );
	startIdleTime=GetIdleTime();
	while ( blocksLeft > dontcnt)
	{
        cbTotalTx = 0;
        do
		{
          cbXfer = sendto(sock, pBuf+cbTotalTx, BUFFER_SIZE-cbTotalTx, 0, 
            AI->ai_addr, AI->ai_addrlen);
		  if(cbXfer == SOCKET_ERROR)
		  {
            printf("ERROR: S3 sendto() Error=%d cbXfer=%d\r\n", WSAGetLastError(), cbXfer);
		   break;
		  }   
          cbTotalTx += cbXfer;
		} while(cbXfer > 0 && cbTotalTx<BUFFER_SIZE);

        if(cbTotalTx != BUFFER_SIZE)
		{
          printf("ERROR: S5 cbTotalTx=%d\r\n", cbTotalTx);
          break;
		} else {