void
swat_wmiconfig_suspstart(A_UINT32 susp_time)
{
//notice: nvram_init will cause jtag hung.
qcom_nvram_init(); /* sometimes this function is not called, and fini call will crash */
qcom_nvram_fini(); //power down flash before go to suspend mode
if(qcom_suspend_start(susp_time) == A_ERROR){
SWAT_PTF("Store recall failed\n");
}
}
void
swat_database_print(STREAM_CXT_t * pCxtPara)
{
SWAT_PTF("\nindex:%d,socketLocal:%d,clientFd:%d\n", pCxtPara->index,
pCxtPara->socketLocal, pCxtPara->clientFd[DEFAULT_FD_INDEX]);
/* Bench Para */
IPV4_PTF(pCxtPara->param.ipAddress);
SWAT_PTF(":%d,%d,size:%d,mode %d,time %d s/pkts %d \n",
pCxtPara->param.port,
pCxtPara->param.protocol,
pCxtPara->param.pktSize,
pCxtPara->param.mode, pCxtPara->param.seconds, pCxtPara->param.numOfPkts);
/* Calc Para */
SWAT_PTF("firsttime:%d,lasttime:%d,bytes:%d,Kbytes:%d \n",
pCxtPara->calc[DEFAULT_FD_INDEX].firstTime.milliseconds, pCxtPara->calc[DEFAULT_FD_INDEX].lastTime.milliseconds,
pCxtPara->calc[DEFAULT_FD_INDEX].bytes, pCxtPara->calc[DEFAULT_FD_INDEX].kbytes);
}
void
swat_bench_dbg()
{
A_UINT32 index = 0;
A_UINT32 ret = 0;
extern A_UINT32 allocram_remaining_bytes;
SWAT_PTF("### SWAT MEM FREE : %d.\n", allocram_remaining_bytes);
for (index = 0; index < CALC_STREAM_NUMBER; index++) {
/*tcpTx */
SWAT_PTF("\ntcpTx[%d]:\n", index);
ret = swat_cxt_index_find(&tcpTxIndex[index]);
if (CALC_STREAM_NUMBER_INVALID == ret) {
swat_database_print(&cxtTcpTxPara[index]);
}
/*tcpRx */
SWAT_PTF("\ntcpRx[%d]:\n", index);
ret = swat_cxt_index_find(&tcpRxIndex[index]);
if (CALC_STREAM_NUMBER_INVALID == ret) {
swat_database_print(&cxtTcpRxPara[index]);
}
/*udpTx */
SWAT_PTF("\nudpTx[%d]:\n", index);
ret = swat_cxt_index_find(&udpTxIndex[index]);
if (CALC_STREAM_NUMBER_INVALID == ret) {
swat_database_print(&cxtUdpTxPara[index]);
}
/*udpRx */
SWAT_PTF("\nudpRx[%d]:\n", index);
ret = swat_cxt_index_find(&udpRxIndex[index]);
if (CALC_STREAM_NUMBER_INVALID == ret) {
swat_database_print(&cxtUdpRxPara[index]);
}
#if SWAT_BENCH_RAW
/*rawTx*/
SWAT_PTF("\nrawTx[%d]:\n",index);
ret = swat_cxt_index_find(&rawTxIndex[index]);
if (CALC_STREAM_NUMBER_INVALID == ret)
{
swat_database_print(&cxtRawTxPara[index]);
}
/*rawRx*/
SWAT_PTF("\nrawRx[%d]:\n",index);
ret = swat_cxt_index_find(&rawRxIndex[index]);
if (CALC_STREAM_NUMBER_INVALID == ret)
{
swat_database_print(&cxtRawRxPara[index]);
}
#endif
}
}
void
swat_test_result_print(STREAM_CXT_t * pCxtPara, A_UINT32 index)
{
A_UINT32 throughput = 0;
A_UINT32 totalBytes = 0;
A_UINT32 totalKbytes = 0;
A_UINT32 msInterval = 0;
A_UINT32 totalInterval = 0;
A_UINT32 sInterval = 0;//seconds
msInterval = (pCxtPara->calc[index].lastTime.milliseconds - pCxtPara->calc[index].firstTime.milliseconds);
totalInterval = msInterval;
sInterval = totalInterval/1000;
if (totalInterval > 0) {
if ((0 == pCxtPara->calc[index].bytes)
&& (0 == pCxtPara->calc[index].kbytes)) {
throughput = 0;
} else {
/*when calc.kbytes >0x7FFFF, the value of (pCxtPara->calc.kbytes * 1024 * 8)
will overflow */
if (pCxtPara->calc[index].kbytes < 0x7FFFF){
throughput =
((pCxtPara->calc[index].kbytes * 1024 * 8) / (totalInterval)) +
((pCxtPara->calc[index].bytes * 8) / (totalInterval));
}
else{
throughput =((pCxtPara->calc[index].kbytes * 8) / (sInterval))
+ ((pCxtPara->calc[index].bytes * 8/1024) / (sInterval));
}
totalBytes = pCxtPara->calc[index].bytes;
totalKbytes = pCxtPara->calc[index].kbytes;
}
} else {
throughput = 0;
}
switch (pCxtPara->param.protocol) {
case TEST_PROT_UDP:
{
if (TEST_DIR_RX == pCxtPara->param.direction) {
SWAT_PTF("\nResults for %s test:\n\n", "UDP Receive");
} else {
SWAT_PTF("\nResults for %s test:\n\n", "UDP Transmit");
}
break;
}
case TEST_PROT_SSL:
case TEST_PROT_TCP:
{
if (TEST_DIR_RX == pCxtPara->param.direction) {
SWAT_PTF("\nResults for %s test:\n\n", "TCP Receive");
} else {
SWAT_PTF("\nResults for %s test:\n\n", "TCP Transmit");
}
break;
}
#if SWAT_BENCH_RAW
case TEST_PROT_RAW:
{
if (TEST_DIR_RX == pCxtPara->param.direction)
{
SWAT_PTF("\nResults for %s test:\n\n", "RAW Receive");
}
else
{
SWAT_PTF("\nResults for %s test:\n\n", "RAW Transmit");
}
break;
}
#endif
default:
{
SWAT_PTF("\nUnknown Protocol:\n\n");
break;
}
}
SWAT_PTF("\t%d Bytes in %d seconds %d ms \n", totalKbytes * 1024 + totalBytes,
totalInterval / 1000, totalInterval % 1000);
SWAT_PTF("\t%d KBytes %d bytes in %d seconds %d ms \n\n", totalKbytes, totalBytes,
totalInterval / 1000, totalInterval % 1000);
SWAT_PTF("\t throughput %d kb/sec\n", throughput);
}
void
swat_tcp_tx_handle(STREAM_CXT_t * pStreamCxt)
{
A_INT32 sendBytes = 0;
A_UINT32 sumBytes = 0;
A_UINT32 currentPackets = 0;
A_UINT8 *pDataBuffer = NULL;
SWAT_PTR_NULL_CHK(pStreamCxt);
/* Initial Bench Value */
swat_bench_quit_init();
/* Initial Calc & Time */
pStreamCxt->calc.firstTime.milliseconds = CALC_TIME_DEF;
pStreamCxt->calc.lastTime.milliseconds = CALC_TIME_DEF;
pStreamCxt->calc.bytes = CALC_BYTES_DEF;
pStreamCxt->calc.kbytes = CALC_KBYTES_DEF;
/* Malloc Packet Buffer Size */
pDataBuffer = swat_mem_malloc(pStreamCxt->param.pktSize);
if (NULL == pDataBuffer) {
SWAT_PTF("TCP TX data buffer malloc error\r\n");
/* Close Socket */
swat_socket_close(pStreamCxt);
return;
}
pStreamCxt->param.pktBuff = pDataBuffer;
/* Initial Packet */
SWAT_PTF("Sending...\r\n");
/* Get First Time */
swat_get_first_time(pStreamCxt);
if (TEST_MODE_TIME == pStreamCxt->param.mode) {
swat_bench_timer_init(pStreamCxt->param.seconds, pStreamCxt->param.protocol,
pStreamCxt->index);
}
while (1) {
if (swat_bench_quit()) {
/* Get Last Time For Pressure */
//SWAT_PTF("Warning Bench Quit!!\n");
swat_get_last_time(pStreamCxt);
break;
}
sendBytes =
swat_send(pStreamCxt->socketLocal, (char *) pDataBuffer,
pStreamCxt->param.pktSize, 0);
/*delay */
if (pStreamCxt->param.delay){
qcom_thread_msleep(pStreamCxt->param.delay);
}
if (sendBytes < 0) {
if (TX_BUFF_FAIL == sendBytes) {
/* buff full will send fail, it should be normal */
SWAT_PTF("[bench id %d, port %d]buffer full\r\n", pStreamCxt->index,
NTOHS(pStreamCxt->param.port));
} else {
SWAT_PTF
("[bench id %d, port %d]TCP Socket send is error %d sumBytes = %d\r\n",
pStreamCxt->index, NTOHS(pStreamCxt->param.port), sendBytes, sumBytes);
swat_get_last_time(pStreamCxt);
break;
}
} else {
/* bytes & kbytes */
sumBytes += sendBytes;
}
if (sendBytes >0){
swat_bytes_calc(pStreamCxt, sendBytes);
}
/* Packets Mode */
if (TEST_MODE_PACKETS == pStreamCxt->param.mode) {
if (0 != (sumBytes / pStreamCxt->param.pktSize)) {
currentPackets += (sumBytes / pStreamCxt->param.pktSize);
sumBytes = sumBytes % pStreamCxt->param.pktSize;
}
if (currentPackets >= pStreamCxt->param.numOfPkts) {
swat_get_last_time(pStreamCxt);
break;
}
}
/* Time Mode */
if (TEST_MODE_TIME == pStreamCxt->param.mode) {
if (0 != benchTcpTxTimerStop[pStreamCxt->index]) {
swat_get_last_time(pStreamCxt);
break;
}
}
}
swat_test_result_print(pStreamCxt);
SWAT_PTF("IOT Throughput Test Completed.\n");
/* Free Buffer */
swat_buffer_free(&(pStreamCxt->param.pktBuff));
/* Close Socket */
swat_socket_close(pStreamCxt);
}
void
swat_udp_rx_data(STREAM_CXT_t * pStreamCxt)
{
A_INT32 recvBytes = 0;
A_INT32 fromSize = 0;
A_UINT32 sumBytes = 0;
A_UINT8 *pDataBuffer = NULL;
struct sockaddr_in fromAddr;
q_fd_set sockSet;
struct timeval tmo;
A_INT32 fdAct = 0;
A_UINT32 isFirst = 1;
A_UINT32 clientIp = 0;
A_UINT16 clientPort = 0;
A_UINT32 totalInterval = 0;
A_UINT32 sendBytes = 0;
STAT_PACKET_t StatPacket;
A_INT32 sendTerminalCount = 0;
SWAT_PTR_NULL_CHK(pStreamCxt);
/* Initial Calc & Time */
pStreamCxt->calc.firstTime.milliseconds = CALC_TIME_DEF;
pStreamCxt->calc.lastTime.milliseconds = CALC_TIME_DEF;
pStreamCxt->calc.bytes = CALC_BYTES_DEF;
pStreamCxt->calc.kbytes = CALC_KBYTES_DEF;
/* Initial Bench Value */
swat_bench_quit_init();
/* Malloc Packet Buffer Size */
pDataBuffer = swat_mem_malloc(pStreamCxt->param.pktSize);
if (NULL == pDataBuffer) {
SWAT_PTF("UDP RX data buffer malloc error\r\n");
return;
}
pStreamCxt->param.pktBuff = pDataBuffer;
memset(&StatPacket, 0, sizeof (StatPacket));
/* Prepare IP address & port */
memset(&fromAddr, 0, sizeof (struct sockaddr_in));
fromSize = sizeof (struct sockaddr_in);
/* Init fd_set */
swat_fd_zero(&sockSet);
swat_fd_set(pStreamCxt->socketLocal, &sockSet);
pStreamCxt->pfd_set = (void *) &sockSet;
tmo.tv_sec = 300;
tmo.tv_usec = 0;
/* Get First Time */
swat_get_first_time(pStreamCxt);
while (1) {
if (swat_bench_quit()) {
/* Get Last Time For Pressure */
//SWAT_PTF("Bench quit!!\r\n");
swat_get_last_time(pStreamCxt);
//swat_bytes_calc(pStreamCxt, sumBytes);
break;
}
/* Wait for Input */
fdAct = swat_select(pStreamCxt->socketLocal + 1, &sockSet, NULL, NULL, &tmo); //k_select()
if (0 != fdAct) {
if (swat_fd_isset(pStreamCxt->socketLocal, &sockSet)) {
recvBytes = swat_recvfrom(pStreamCxt->socketLocal, (char*) pDataBuffer,
pStreamCxt->param.pktSize, 0,
(struct sockaddr *) &fromAddr, &fromSize);
if (recvBytes <= 0) {
SWAT_PTF("UDP Socket receive is error %d, sumBytes = %d\r\n", recvBytes,
sumBytes);
break;
}
if (recvBytes >= sizeof (EOT_PACKET_t)) {
if (isFirst) {
if (recvBytes > sizeof (EOT_PACKET_t)) {
clientIp = NTOHL(fromAddr.sin_addr.s_addr);
clientPort = NTOHS(fromAddr.sin_port);
SWAT_PTF("UDP receving from %d.%d.%d.%d port:%d \r\n",
(clientIp) >> 24 & 0xFF, (clientIp) >> 16 & 0xFF,
(clientIp) >> 8 & 0xFF, (clientIp) & 0xFF, clientPort);
isFirst = 0;
swat_get_first_time(pStreamCxt);
}
swat_bytes_calc(pStreamCxt, recvBytes);
} else {
/*End packet is not count*/
if (recvBytes > sizeof (EOT_PACKET_t)) {
swat_bytes_calc(pStreamCxt, recvBytes);
}
else {
/* Update Port */
fromAddr.sin_port = HTONS(pStreamCxt->param.port);
fromAddr.sin_family = AF_INET; /* End Of Transfer */
swat_get_last_time(pStreamCxt);
totalInterval =
(pStreamCxt->calc.lastTime.milliseconds -
pStreamCxt->calc.firstTime.milliseconds);
StatPacket.kbytes = pStreamCxt->calc.kbytes;
StatPacket.bytes = pStreamCxt->calc.bytes;
StatPacket.msec = totalInterval;
/* Tell ath_console TX received end mark AABBCCDD with throughput value */
while (sendTerminalCount <= 10) {
/* Wait for Output */
fdAct = swat_select(pStreamCxt->socketLocal + 1, NULL, &sockSet, NULL, &tmo); //k_select()
if (0 != fdAct) {
if (swat_fd_isset(pStreamCxt->socketLocal, &sockSet)) {
sendBytes = swat_sendto(pStreamCxt->socketLocal,
(char *) (&StatPacket),
sizeof (STAT_PACKET_t), 0,
(struct sockaddr *) &fromAddr,
sizeof (struct sockaddr_in));
if (sendBytes < 0) {
SWAT_PTF
("UDP send throughput info packet error %d , retry %d \r\n",
sendBytes, sendTerminalCount);
qcom_thread_msleep(100);
} else {
/* Clean */
tmo.tv_sec = 2;
tmo.tv_usec = 0;
while (recvBytes == sizeof (EOT_PACKET_t)) {
fdAct = swat_select(pStreamCxt->socketLocal + 1, &sockSet, NULL, NULL, &tmo); //k_select()
if (0 == fdAct) {
SWAT_PTF("UDP break\n");
break;
}
if (swat_fd_isset(pStreamCxt->socketLocal, &sockSet)) {
recvBytes = swat_recvfrom(pStreamCxt->socketLocal, (char*) pDataBuffer,
pStreamCxt->param.pktSize, 0,
(struct sockaddr *) &fromAddr, &fromSize);
}
}
break;
}
}
}
sendTerminalCount++;
}
break;
}
}
}
}
void
swat_udp_tx_handle(STREAM_CXT_t * pStreamCxt)
{
A_INT32 sendBytes = 0;
A_INT32 fromSize = 0;
A_UINT32 sumBytes = 0;
A_UINT32 currentPackets = 0;
A_UINT8 *pDataBuffer = NULL;
struct sockaddr_in remoteAddr;
struct sockaddr_in fromAddr;
EOT_PACKET_t eotPacket;
A_INT32 sendTerminalCount = 0;
SWAT_PTR_NULL_CHK(pStreamCxt);
/* Initial Bench Value */
swat_bench_quit_init();
/* Initial Calc & Time */
pStreamCxt->calc.firstTime.milliseconds = CALC_TIME_DEF;
pStreamCxt->calc.lastTime.milliseconds = CALC_TIME_DEF;
pStreamCxt->calc.bytes = CALC_BYTES_DEF;
pStreamCxt->calc.kbytes = CALC_KBYTES_DEF;
/* Malloc Packet Buffer Size */
pDataBuffer = swat_mem_malloc(pStreamCxt->param.pktSize);
if (NULL == pDataBuffer) {
SWAT_PTF("UDP TX data buffer malloc error\r\n");
/* Close Socket */
swat_socket_close(pStreamCxt);
return;
}
pStreamCxt->param.pktBuff = pDataBuffer;
/* Prepare IP address & port */
memset(&remoteAddr, 0, sizeof (struct sockaddr_in));
memset(&fromAddr, 0, sizeof (struct sockaddr_in));
remoteAddr.sin_addr.s_addr = HTONL(pStreamCxt->param.ipAddress);
remoteAddr.sin_port = HTONS(pStreamCxt->param.port);
remoteAddr.sin_family = AF_INET;
fromSize = sizeof (struct sockaddr_in);
/* Initial Packet */
SWAT_PTF("UDP IP %d.%d.%d.%d prepare OK\r\n",
(pStreamCxt->param.ipAddress) >> 24 & 0xFF, (pStreamCxt->param.ipAddress) >> 16 & 0xFF,
(pStreamCxt->param.ipAddress) >> 8 & 0xFF, (pStreamCxt->param.ipAddress) & 0xFF);
SWAT_PTF("Sending...\r\n");
/* Get First Time */
swat_get_first_time(pStreamCxt);
if (TEST_MODE_TIME == pStreamCxt->param.mode) {
swat_bench_timer_init(pStreamCxt->param.seconds, pStreamCxt->param.protocol,
pStreamCxt->index);
}
while (1) {
if (swat_bench_quit()) {
/* Get Last Time For Pressure */
//SWAT_PTF("Bench quit!!\r\n");
swat_get_last_time(pStreamCxt);
break;
}
sendBytes = swat_sendto(pStreamCxt->socketLocal, (char*) pDataBuffer,
pStreamCxt->param.pktSize, 0,
(struct sockaddr *) &remoteAddr, sizeof (struct sockaddr_in));
/*delay */
if (pStreamCxt->param.delay){
qcom_thread_msleep(pStreamCxt->param.delay);
}
if (sendBytes < 0) {
SWAT_PTF("UDP Socket send is error %d sumBytes = %d\r\n", sendBytes, sumBytes);
/* Free Buffer */
//swat_buffer_free(&(pStreamCxt->param.pktBuff));
qcom_thread_msleep(100);
//break;
} else {
/* bytes & kbytes */
sumBytes += sendBytes;
}
if (sendBytes > 0){
swat_bytes_calc(pStreamCxt, sendBytes);
}
/* Packets Mode */
if (TEST_MODE_PACKETS == pStreamCxt->param.mode) {
if (0 != (sumBytes / pStreamCxt->param.pktSize)) {
currentPackets += (sumBytes / pStreamCxt->param.pktSize);
sumBytes = sumBytes % pStreamCxt->param.pktSize;
}
if (currentPackets >= pStreamCxt->param.numOfPkts) {
swat_get_last_time(pStreamCxt);
break;
}
}
/* Time Mode */
if (TEST_MODE_TIME == pStreamCxt->param.mode) {
/* Get Last Time */
if (0 != benchUdpTxTimerStop[pStreamCxt->index]) {
swat_get_last_time(pStreamCxt);
break;
}
}
}
int send_fail = 0;
/* Tell ath_console TX is complete end mark is AABBCCDD */
while (send_fail <= 10) {
eotPacket.code = 0xAABBCCDD;
eotPacket.packetCount = currentPackets;
sendBytes = swat_sendto(pStreamCxt->socketLocal, (char *) & eotPacket,
sizeof (EOT_PACKET_t), 0, (struct sockaddr *) &remoteAddr,
sizeof (struct sockaddr_in));
if (sendBytes < 0) {
SWAT_PTF("UDP send terminate packet error %d , retry %d \r\n", sendBytes,
sendTerminalCount);
send_fail ++;
qcom_thread_msleep(100);
} else {
qcom_thread_msleep(100);
sendTerminalCount++;
if(sendTerminalCount > 2)
break;
}
}
swat_test_result_print(pStreamCxt);
SWAT_PTF("*************IOT Throughput Test Completed **************\n");
/* Free Buffer */
swat_buffer_free(&(pStreamCxt->param.pktBuff));
/* Close Socket */
swat_socket_close(pStreamCxt);
}
void
swat_tcp_rx_handle(STREAM_CXT_t * pStreamCxt)
{
A_INT32 ret = 0;
A_UINT32 clientIp;
A_UINT16 clientPort;
A_INT32 clientFd = -1;
A_UINT32 isFirst = 0;
struct sockaddr_in clientAddr;
A_INT32 len = sizeof (struct sockaddr_in);
struct timeval tmo;
A_INT32 fdAct = 0;
q_fd_set sockSet;
SWAT_PTR_NULL_CHK(pStreamCxt);
/* Initial Bench Value */
swat_bench_quit_init();
swat_fd_zero(&sockSet);
swat_fd_set(pStreamCxt->socketLocal, &sockSet);
pStreamCxt->pfd_set = (void *) &sockSet;
tmo.tv_sec = 2;
tmo.tv_usec = 0;
while (1) {
if (0 == isFirst) {
ret = swat_listen(pStreamCxt->socketLocal, 10);
if (ret < 0) {
/* Close Socket */
SWAT_PTF("Failed to listen socket %d.\n", pStreamCxt->socketLocal);
goto QUIT;
}
isFirst = 1;
}
while (1) {
if (swat_bench_quit()) {
goto QUIT;
}
fdAct = swat_select(pStreamCxt->socketLocal, &sockSet, NULL, NULL, &tmo); //k_select()
if (fdAct != 0) {
break;
}
}
clientFd = swat_accept(pStreamCxt->socketLocal, (struct sockaddr *) &clientAddr, &len);
if (clientFd < 0) {
/* Close Socket */
SWAT_PTF("Failed to accept socket %d.\n", clientFd);
goto QUIT;
}
clientIp = NTOHL(clientAddr.sin_addr.s_addr);
clientPort = NTOHS(clientAddr.sin_port);
pStreamCxt->clientFd = clientFd;
SWAT_PTF("Receiving from %d.%d.%d.%d Remote port:%d \r\n",
(clientIp) >> 24 & 0xFF, (clientIp) >> 16 & 0xFF,
(clientIp) >> 8 & 0xFF, (clientIp) & 0xFF, clientPort);
/* Initial Calc & Time */
pStreamCxt->calc.firstTime.milliseconds = CALC_TIME_DEF;
pStreamCxt->calc.lastTime.milliseconds = CALC_TIME_DEF;
pStreamCxt->calc.bytes = CALC_BYTES_DEF;
pStreamCxt->calc.kbytes = CALC_KBYTES_DEF;
swat_tcp_rx_data(pStreamCxt);
/* Close Client Socket */
swat_close(pStreamCxt->clientFd);
pStreamCxt->clientFd = -1;
}
QUIT:
swat_test_result_print(pStreamCxt);
SWAT_PTF("*************IOT Throughput Test Completed **************\n");
SWAT_PTF("Shell> ");
/* Init fd_set */
swat_fd_zero(&sockSet);
pStreamCxt->pfd_set = NULL;
/* Close Socket */
swat_socket_close(pStreamCxt);
}
void
swat_tcp_rx_data(STREAM_CXT_t * pStreamCxt)
{
A_INT32 recvBytes = 0;
A_UINT8 *pDataBuffer = NULL;
struct timeval tmo;
A_INT32 fdAct = 0;
q_fd_set sockSet;
SWAT_PTR_NULL_CHK(pStreamCxt);
/* Initial pBuffer */
/* Malloc Packet Buffer Size */
pDataBuffer = swat_mem_malloc(pStreamCxt->param.pktSize);
if (NULL == pDataBuffer) {
SWAT_PTF("TCP RX data buffer malloc error\r\n");
return;
}
pStreamCxt->param.pktBuff = pDataBuffer;
/* Initial Packet */
swat_mem_set(pDataBuffer, 0, sizeof (A_UINT8) * pStreamCxt->param.pktSize);
/* Get First Time */
swat_get_first_time(pStreamCxt);
swat_fd_zero(&sockSet);
swat_fd_set(pStreamCxt->clientFd, &sockSet);
pStreamCxt->pfd_set = (void *) &sockSet;
tmo.tv_sec = 300;
tmo.tv_usec = 0;
while (1) {
if (swat_bench_quit()) {
/* Get Last Time For Pressure */
//SWAT_PTF("Bench quit!!\r\n");
swat_get_last_time(pStreamCxt);
break;
}
/* Wait for Input */
fdAct = swat_select(pStreamCxt->clientFd + 1, &sockSet, NULL, NULL, &tmo); //k_select()
if (0 != fdAct) {
if (swat_fd_isset(pStreamCxt->clientFd, &sockSet)) {
recvBytes =
swat_recv(pStreamCxt->clientFd, (char *) pDataBuffer, pStreamCxt->param.pktSize,
0);
if (recvBytes <= 0) {
swat_get_last_time(pStreamCxt);
break;
} else {
swat_bytes_calc(pStreamCxt, recvBytes);
}
}
}
else{
SWAT_PTF("TCP Rx idle time is over 60s and exit now\n");
swat_get_last_time(pStreamCxt);
break;
}
}
swat_test_result_print(pStreamCxt);
SWAT_PTF("Waiting.\n");
/* Free Buffer */
swat_buffer_free(&(pStreamCxt->param.pktBuff));
swat_fd_zero(&sockSet);
pStreamCxt->pfd_set = NULL;
}
