接着昨天的继续，这个程序实现的功能是将原有的Socket程序的每个阶段的运行时间进行统计，计算每个阶段最大运行时间和平均运行时间并输出。
这个程序将原有的程序作为外部函数，调用并返回所需要的所有的运行时间（结构体类型）。
贴代码：
#define _CRT_SECURE_NO_WARNINGS
#define PORT 8888 /*定义端口*/
#define MAXDATA 1000 /*定义最大传输数量*/
#define T 100
#define MAX_RUN 3
#define MAX_MAIN 3
#pragma comment(lib, "ws2_32.lib")
#include <windows.h>
#include <time.h>
#include <stdlib.h>
#include <stdio.h>
struct Time
{
long int modeTime;
long int connectTime;
long int messageTime;
long int exeTime[MAX_RUN];
long int waitTime[MAX_RUN];
long int runTime[MAX_RUN];
}allTime;
int gettimeofday(struct timeval *tp, void *tzp)
{
time_t clock;
struct tm tm;
SYSTEMTIME wtm;
GetLocalTime(&wtm);
tm.tm_year = wtm.wYear - 1900;
tm.tm_mon = wtm.wMonth - 1;
tm.tm_mday = wtm.wDay;
tm.tm_hour = wtm.wHour;
tm.tm_min = wtm.wMinute;
tm.tm_sec = wtm.wSecond;
tm.tm_isdst = -1;
clock = mktime(&tm);
tp->tv_sec = clock;
tp->tv_usec = wtm.wMilliseconds * 1000;
return (0);
}
int exe(void)
{
long i = 100000000L;
while (i--);
return 0;
}
struct Time run(void)
{
/*各种声明定义*/
SOCKET server;
SOCKET client;
struct sockaddr_in serveraddr;
struct sockaddr_in clientaddr;
WSADATA wsaData;
int len = sizeof(struct sockaddr_in);
int exeTime, serverTime_i, clientTime_i, ret_1, ret_cyc, ret_time_server, ret_time_client;
int dec_1, sign_1, dec_2, sign_2;
int t = T;
int con = -1;
int port, i;
char receiveData[MAXDATA];
char runData[MAXDATA];
char *readyMessage_server = "I'm ready !\n";
char *readyMessage_client = "I'm ready too !\n";
char *runMessage = "Run !\n";
char serverTime_c[MAXDATA], *serverTime_c_server, clientTime_c[MAXDATA], *clientTime_c_client;
char waitTime, serverTime_d, clientTime_d;
clock_t startRun, endRun;
struct timeval start, end, waitstart, waitend, exestart, exeend;
long int exeSum = 0, waitSum = 0, runSum = 0;
/*w微妙计时开始*/
gettimeofday(&start, NULL);
/*选择服务器或客户端*/
printf("Please choose server of client.\n1.Server 2.Client\n");
scanf("%d", &port);
/*服务端*/
if (port == 1)
{
/*微妙计时结束，计算连接时间*/
gettimeofday(&end, NULL);
allTime.modeTime = 1000000 * (end.tv_sec - start.tv_sec) + end.tv_usec - start.tv_usec;
/*微妙计时开始*/
gettimeofday(&start, NULL);
/*启动windows的socket服务，初始化WSA*/
WSAStartup(0x101, &wsaData);
/*创建服务端，初始化服务器地址*/
memset((void *)&serveraddr, 0, sizeof(serveraddr));
/*创建服务器套接字*/
server = socket(AF_INET, SOCK_STREAM, 0);
if (server == -1)
{
printf("Socket error !");
getchar();
exit(1);
}
/*绑定IP和端口*/
serveraddr.sin_family = AF_INET; /*定义家族协议*/
serveraddr.sin_addr.s_addr = inet_addr("127.0.0.1"); /*定义主机地址*/
serveraddr.sin_port = htons(PORT); /*定义主机端口*/
if (bind(server, (struct sockaddr *)&serveraddr, sizeof(serveraddr)) == -1) /*绑定成功返回0*/
{
printf("Bind error !");
getchar();
exit(1);
}
/*开始监听*/
if (listen(server, 20) == -1)
{
printf("Listen error !");
getchar();
exit(1);
}
/*建立连接*/
printf("Waiting for connection...\n\n");
client = accept(server, (SOCKADDR *)&clientaddr, &len);
if (client == -1)
{
printf("accept error !");
getchar();
exit(1);
}
printf("Receive a connection: %s \r\n\n", inet_ntoa(clientaddr.sin_addr));
/*微妙计时结束，计算连接时间*/
gettimeofday(&end, NULL);
allTime.connectTime = 1000000 * (end.tv_sec - start.tv_sec) + end.tv_usec - start.tv_usec;
/*微妙计时开始*/
gettimeofday(&start, NULL);
/*发送准备信息*/
if (send(client, readyMessage_server, strlen(readyMessage_server), 0) < 0)
{
printf("\n\nSend error or connection interruption !\n");
getchar();
exit(1);
}
/*接受准备信息*/
int ret_1 = recv(client, receiveData, MAXDATA, 0);
if (ret_1 > 0)
{
receiveData[ret_1] = 0x00;
printf("From client %s: %s", inet_ntoa(clientaddr.sin_addr), receiveData);
}
/*接收不到客户端数据时中断循环*/
else
{
printf("\n\nReceive error or connection interruption !\n");
getchar();
exit(1);
}
/*发出运行许可指令*/
if (strcmp(receiveData, readyMessage_client) == 0)
{
if (send(client, runMessage, strlen(runMessage), 0) < 0)
{
printf("\n\nSend error or connection interruption !\n");
getchar();
exit(1);
}
}
/*微妙计时结束，计算消息时间*/
gettimeofday(&end, NULL);
allTime.messageTime = 1000000 * (end.tv_sec - start.tv_sec) + end.tv_usec - start.tv_usec;
for (i = 0; i < MAX_RUN; i++)
{
/*微妙计时开始*/
gettimeofday(&start, NULL);
/*运行时间大于周期时间，则直接运行*/
if (t >= T)
{
/*微妙几时开始*/
gettimeofday(&exestart, NULL);
/*计时开始*/
startRun = clock();
exe();
/*计时结束*/
endRun = clock();
/*微妙计时结束，计算运行时间*/
gettimeofday(&exeend, NULL);
allTime.exeTime[i] = 1000000 * (exeend.tv_sec - exestart.tv_sec) + exeend.tv_usec - exestart.tv_usec;
exeSum += allTime.exeTime[i];
printf("exeTime[%d]=%ld\n", i, allTime.exeTime[i]);
/*服务端运行用时*/
serverTime_d = (double)(endRun - startRun);
/*服务端运行用时转字符串*/
_ecvt(serverTime_d, 10, &dec_1, &sign_1);
serverTime_c_server = _ecvt(serverTime_d, dec_1, &dec_2, &sign_2);
/*发送服务端运行用时*/
if (send(client, serverTime_c_server, strlen(serverTime_c_server), 0) < 0)
{
printf("\n\nSend error or connection interruption !\n");
getchar();
exit(1);
}
/*接收客户端运行用时*/
ret_time_client = recv(client, clientTime_c, MAXDATA, 0);
if (ret_time_client > 0)
{
clientTime_c[ret_time_client] = 0x00;
}
/*接收不到客户端数据终端循环*/
else
{
printf("\n\nReceive error or connection interruption !\n");
getchar();
exit(1);
}
/*字符串转整形*/
serverTime_i = atoi(serverTime_c_server);
printf("Server's operation time is %d\n", serverTime_i);
clientTime_i = atoi(clientTime_c);
printf("Client's operation time is %d\n", clientTime_i);
/*比较服务端、客户端用时长短*/
if (serverTime_i >= clientTime_i)
{
exeTime = serverTime_i;
}
else
{
exeTime = clientTime_i;
}
t = exeTime;
printf("The whole system's opration time is %d\n\n", t);
/*运行总时长小于周期时间，挂起*/
if (t <= T)
{
/*微妙几时开始*/
gettimeofday(&waitstart, NULL);
waitTime = T - t;
Sleep(waitTime);
t = T;
/*微妙计时结束，计算运行时间*/
gettimeofday(&waitend, NULL);
allTime.waitTime[i] = 1000000 * (waitend.tv_sec - waitstart.tv_sec) + waitend.tv_usec - waitstart.tv_usec;
waitSum += allTime.waitTime[i];
}
else
{
allTime.waitTime[i] = 0;
}
}
/*微妙计时结束，计算运行时间*/
gettimeofday(&end, NULL);
allTime.runTime[i] = 1000000 * (end.tv_sec - start.tv_sec) + end.tv_usec - start.tv_usec;
printf("connectTime=%ld, messageTime=%ld, runTime=%ld\n", allTime.connectTime, allTime.messageTime, allTime.runTime);
}
printf("modeTime=%ld, connectTime=%ld, messageTime=%ld\n", allTime.modeTime, allTime.connectTime, allTime.messageTime);
printf("exeTime=%ld, wait=%ld, run=%ld\n\n", exeSum / MAX_RUN, waitSum / MAX_RUN, runSum / MAX_RUN);
closesocket(server);
WSACleanup();
}
/*客户端*/
else
{
/*微妙计时结束，计算连接时间*/
gettimeofday(&end, NULL);
allTime.modeTime = 1000000 * (end.tv_sec - start.tv_sec) + end.tv_usec - start.tv_usec;
/*微妙计时开始*/
gettimeofday(&start, NULL);
/*启动windows的socket服务，初始化WSA*/
WSAStartup(0x101, &wsaData);
/*创建服务端，初始化服务器地址*/
memset((void *)&clientaddr, 0, sizeof(clientaddr));
/*创建服务器套接字*/
client = socket(AF_INET, SOCK_STREAM, 0);
if (client == -1)
{
printf("Socket error !");
getchar();
exit(1);
}
/*绑定IP和端口*/
clientaddr.sin_family = AF_INET; /*定义家族协议*/
clientaddr.sin_addr.s_addr = inet_addr("127.0.0.1"); /*定义主机地址*/
clientaddr.sin_port = htons(PORT); /*定义主机端口*/
/*启动程序时循环连接服务端*/
while (con == -1)
{
con = connect(client, (struct sockaddr *)&clientaddr, sizeof(clientaddr));
if (con == -1)
{
printf("Connection error !\n");
}
}
/*微妙计时结束，计算连接时间*/
gettimeofday(&end, NULL);
allTime.connectTime = 1000000 * (end.tv_sec - start.tv_sec) + end.tv_usec - start.tv_usec;
/*微妙计时开始*/
gettimeofday(&start, NULL);
/*接收准备信息*/
ret_1 = recv(client, receiveData, MAXDATA, 0);
if (ret_1 > 0)
{
receiveData[ret_1] = 0x00;
printf("From server: %s", receiveData);
}
/*接受不到客户端数据时中断循环*/
else
{
printf("\n\nReceive error or connection interruption !\n");
getchar();
exit(1);
}
/*发送准备信息*/
if (send(client, readyMessage_client, strlen(readyMessage_client), 0) < 0)
{
printf("\n\nSend error or connection interruption !\n");
getchar();
exit(1);
}
/*接收运行许可指令*/
ret_cyc = recv(client, runData, MAXDATA, 0);
if (ret_cyc > 0)
{
runData[ret_cyc] = 0x00;
}
/*接收不到服务端数据时中断循环*/
else
{
printf("\n\nReceive error or connection interruption !\n");
getchar();
exit(1);
}
/*微妙计时结束，计算消息时间*/
gettimeofday(&end, NULL);
allTime.messageTime = 1000000 * (end.tv_sec - start.tv_sec) + end.tv_usec - start.tv_usec;
/*检验运行许可指令并开始执行*/
if (strcmp(runData, runMessage) == 0)
{
for (i = 0; i < MAX_RUN; i++)
{
/*微妙计时开始*/
gettimeofday(&start, NULL);
/*运行时间大于周期时间，则直接运行*/
if (t >= T)
{
/*微妙几时开始*/
gettimeofday(&exestart, NULL);
/*计时开始*/
startRun = clock();
exe();
/*计时结束*/
endRun = clock();
/*微妙计时结束，计算运行时间*/
gettimeofday(&exeend, NULL);
allTime.exeTime[i] = 1000000 * (exeend.tv_sec - exestart.tv_sec) + exeend.tv_usec - exestart.tv_usec;
exeSum += allTime.exeTime[i];
/*客户端运行用时*/
clientTime_d = (double)(endRun - startRun);
/*服务端运行用时转字符串*/
_ecvt(clientTime_d, 10, &dec_1, &sign_1);
clientTime_c_client = _ecvt(clientTime_d, dec_1, &dec_2, &sign_2);
/*发送服务端运行用时*/
if (send(client, clientTime_c_client, strlen(clientTime_c_client), 0) < 0)
{
printf("\n\nSend error or connection interruption !\n");
getchar();
exit(1);
}
/*接收客户端运行用时*/
ret_time_server = recv(client, serverTime_c, MAXDATA, 0);
if (ret_time_server > 0)
{
serverTime_c[ret_time_server] = 0x00;
}
/*接收不到客户端数据时终端循环*/
else
{
printf("\n\nReceive error or connection interruption !\n");
getchar();
exit(1);
}
/*字符串转整形*/
serverTime_i = atoi(serverTime_c);
printf("Server's operation time is %d\n", serverTime_i);
clientTime_i = atoi(clientTime_c_client);
printf("Client's operation time is %d\n", clientTime_i);
/*比较服务端、客户端用时长短*/
if (serverTime_i >= clientTime_i)
{
exeTime = serverTime_i;
}
else
{
exeTime = clientTime_i;
}
t = exeTime;
printf("The whole system's opration time is %d\n\n", t);
/*运行总时长小于周期时间，挂起*/
if (t <= T)
{
/*微妙几时开始*/
gettimeofday(&waitstart, NULL);
waitTime = T - t;
Sleep(waitTime);
t = T;
/*微妙计时结束，计算运行时间*/
gettimeofday(&waitend, NULL);
allTime.waitTime[i] = 1000000 * (waitend.tv_sec - waitstart.tv_sec) + waitend.tv_usec - waitstart.tv_usec;
waitSum += allTime.waitTime[i];
}
else
{
allTime.waitTime[i] = 0;
}
}
/*微妙计时结束，计算运行时间*/
gettimeofday(&end, NULL);
allTime.runTime[i] = 1000000 * (end.tv_sec - start.tv_sec) + end.tv_usec - start.tv_usec;
printf("connectTime=%ld, messageTime=%ld, runTime=%ld\n", allTime.connectTime, allTime.messageTime, allTime.runTime);
}
printf("modeTime=%ld, connectTime=%ld, messageTime=%ld\n", allTime.modeTime, allTime.connectTime, allTime.messageTime);
printf("exeTime=%ld, wait=%ld, run=%ld\n\n", exeSum / MAX_RUN, waitSum / MAX_RUN, runSum / MAX_RUN);
}
closesocket(client);
WSACleanup();
}
return allTime;
}
int main(void)
{
/*各种定义*/
struct Time pTime[MAX_MAIN];
int i, j, k, l;
long int modeTimeMax, connectTimeMax, messageTimeMax, exeTimeMax, waitTimeMax, runTimeMax;
long int modeTimeSum, connectTimeSum, messageTimeSum, exeTimeSum, waitTimeSum, runTimeSum;
long int modeTimeAve, connectTimeAve, messageTimeAve, exeTimeAve, waitTimeAve, runTimeAve;
/*运行程序*/
for (i = 0; i < MAX_MAIN; i++)
{
pTime[i] = run();
}
/*计算选择模式的最大时间*/
for (j = 0, modeTimeMax = 0; j < MAX_MAIN; j++)
{
if (modeTimeMax < pTime[j].modeTime)
{
modeTimeMax = pTime[j].modeTime;
}
}
/*计算连接的最大时间*/
for (j = 0, connectTimeMax = 0; j < MAX_MAIN; j++)
{
if (connectTimeMax < pTime[j].connectTime)
{
connectTimeMax = pTime[j].connectTime;
}
}
/*计算发送接收消息的最大时间*/
for (j = 0, messageTimeMax = 0; j < MAX_MAIN; j++)
{
if (messageTimeMax < pTime[j].messageTime)
{
messageTimeMax = pTime[j].messageTime;
}
}
/*计算执行算法的最大时间*/
for (k = 0, exeTimeMax = 0; k < MAX_MAIN; k++)
{
for (l = 0; l < MAX_RUN; l++)
{
if (exeTimeMax < pTime[k].exeTime[l])
{
exeTimeMax = pTime[k].exeTime[l];
}
}
}
/*计算等待的最大时间*/
for (k = 0, waitTimeMax = 0; k < MAX_MAIN; k++)
{
for (l = 0; l < MAX_RUN; l++)
{
if (waitTimeMax < pTime[k].waitTime[l])
{
waitTimeMax = pTime[k].waitTime[l];
}
}
}
/*计算循环的最大时间*/
for (k = 0, runTimeMax = 0; k < MAX_MAIN; k++)
{
for (l = 0; l < MAX_RUN; l++)
{
if (runTimeMax < pTime[k].runTime[l])
{
runTimeMax = pTime[k].runTime[l];
}
}
}
/*计算选择模式的平均时间*/
for (j = 0, modeTimeSum = 0; j < MAX_MAIN; j++)
{
modeTimeSum += pTime[j].modeTime;
}
modeTimeAve = modeTimeSum / MAX_MAIN;
/*计算连接的平均时间*/
for (j = 0, connectTimeSum = 0; j < MAX_MAIN; j++)
{
connectTimeSum += pTime[j].connectTime;
}
connectTimeAve = connectTimeSum / MAX_MAIN;
/*计算发送接收消息的平均时间*/
for (j = 0, messageTimeSum = 0; j < MAX_MAIN; j++)
{
messageTimeSum += pTime[j].messageTime;
}
messageTimeAve = messageTimeSum / MAX_MAIN;
/*计算执行的平均时间*/
for (k = 0, exeTimeSum = 0; k < MAX_MAIN; k++)
{
for (l = 0; l < MAX_RUN; l++)
{
exeTimeSum += pTime[k].exeTime[l];
}
}
exeTimeAve = exeTimeSum / (MAX_MAIN * MAX_RUN);
/*计算等待的平均时间*/
for (k = 0, waitTimeSum = 0; k < MAX_MAIN; k++)
{
for (l = 0; l < MAX_RUN; l++)
{
waitTimeSum += pTime[k].waitTime[l];
}
}
waitTimeAve = waitTimeSum / (MAX_MAIN * MAX_RUN);
/*计算循环的平均时间*/
for (k = 0, runTimeSum = 0; k < MAX_MAIN; k++)
{
for (l = 0; l < MAX_RUN; l++)
{
runTimeSum += pTime[k].runTime[l];
}
}
runTimeAve = runTimeSum / (MAX_MAIN * MAX_RUN);
/*输出结果*/
printf("modeTimeMax=%ld, modeTimeAve=%ld\n", modeTimeMax, modeTimeAve);
printf("connectTimeMax=%ld, connectTimeAve=%ld\n", connectTimeMax, connectTimeAve);
printf("messageTimeMax=%ld, messageTimeAve=%ld\n", messageTimeMax, messageTimeAve);
printf("exeTimeMax=%ld, exeTimeAve=%ld\n", exeTimeMax, exeTimeAve);
printf("waitTimeMax=%ld, waitTimeAve=%ld\n", waitTimeMax, waitTimeAve);
printf("runTimeMax=%ld, runTimeAve=%ld\n", runTimeMax, runTimeAve);
Sleep(10000000000);
return 0;
}
收获的经验：
- 对于一些新的编译器，像VS2017，可以直接选中某个变量进行改名，而一些比较老的编译器只能用文本替换功能，但文本替换就会存在一个问题，替换短字节时，一些长字节有可能会包含这些短字节从而一起被替换，导致出错，如想要替换end，结果send中也包含end，那send也会一起被替换。
- 函数返回多个值有以下几种方法：①返回指针，②定义全局变量，③返回结构体类型。今天用的是结构体，尝试了结构体类型、结构体函数、结构体数组，下次尝试用指针。
- 对于一些可能经常变动而且出现较多的常量，可以使用宏定义，修改方便。
- 想让程序运行完挂起不退出是，可以考虑使用Sleep()，while(1)也可以实现，但while(1)相当于让程序进入死循环，会极大提高程序CPU占用率，导致电脑变卡甚至死机。