把Socket程序中一些复杂的部分集成成函数，虽然有些代码量比较短没必要集成，但还是锻炼一下这个方法吧。
#define _CRT_SECURE_NO_WARNINGS
#pragma comment(lib,"ws2_32.lib")
#define PORT 8888 /*定义端口*/
#define MODE 1 /*定义服务端*/
#define MAXDATA 100 /*定义最大传输数量*/
#define T 100
#define MAX_MAIN 10
#define MAX_RUN 10
#define MAX_MESSAGE 100
#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 allowTime[MAX_RUN];
long int exeTime[MAX_RUN];
long int calTime[MAX_RUN];
long int waitTime[MAX_RUN];
long int runTime[MAX_RUN];
};
/*微秒计时函数*/
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 = 10000000L;
while (i--);
//printf(" This is a program that needs to be executed !\n");
return 0;
}
/*模式选择函数*/
int modeChoose(void)
{
int mode;
/*选择服务端或客户端*/
printf("Please choose server of client. 1.Server 2.Client\n");
scanf_s("%d", &mode);
getchar();
/*mode = MODE;*/
return mode;
}
/*创建套接字*/
SOCKET creatSocket(void)
{
SOCKET Socket = socket(AF_INET, SOCK_STREAM, 0);
if (Socket == -1)
{
printf("Socket error !");
getchar();
exit(1);
}
return Socket;
}
/*绑定IP端口*/
void bindIP(SOCKET Socket, struct sockaddr_in Socketaddr)
{
/*绑定IP和端口*/
Socketaddr.sin_family = AF_INET; /*定义家族协议*/
Socketaddr.sin_addr.s_addr = inet_addr("127.0.0.1"); /*定义主机地址*/
Socketaddr.sin_port = htons(PORT); /*定义主机端口*/
if (bind(Socket, (struct sockaddr *)&Socketaddr, sizeof(Socketaddr)) == -1) /*绑定成功返回0*/
{
printf("Bind error !");
getchar();
exit(1);
}
}
/*监听*/
void listenSocket(SOCKET Socket)
{
/*开始监听*/
if (listen(Socket, 20) == -1)
{
printf("Listen error !");
getchar();
exit(1);
}
}
SOCKET acceptSocket(SOCKET Socket_1, struct sockaddr_in Socketaddr_2)
{
int len = sizeof(struct sockaddr_in);
SOCKET Socket_2 = accept(Socket_1, (SOCKADDR *)&Socketaddr_2, &len);
if (Socket_2 == -1)
{
printf("Accept error !");
getchar();
exit(1);
}
return Socket_2;
}
void connentSocket( SOCKET Socket, struct sockaddr_in Socketaddr)
{
int con;
/*连接服务端*/
con = -1;
while (con == -1)
{
con = connect(Socket, (struct sockaddr*)&Socketaddr, sizeof(Socketaddr));
if (con == -1)
{
printf("Connect error!\n");
}
}
}
void sendMessage(SOCKET Socket, char *Msg, int len)
{
/*发送准备信息*/
if (send(Socket, Msg, len, 0) < 0)
{
printf("\n\nSend error or connection interruption !\n");
getchar();
exit(1);
}
}
char receiveMessage(SOCKET Socket)
{
int ret;
char receiveData[MAXDATA];
/*接收准备信息*/
ret = recv(Socket, receiveData, MAXDATA, 0);
if (ret > 0)
{
receiveData[ret] = 0x00;
printf("From client: %s\n", receiveData);
}
/*接收不到客户端数据时中断循环*/
else
{
printf("\n\nReceive error or connection interruption !\n");
getchar();
exit(1);
}
return receiveData;
}
/*字符串转换*/
char charChange(double d)
{
int dec_1, sign_1, dec_2, sign_2;
char c;
_ecvt(d, 10, &dec_1, &sign_1);
c = _ecvt(d, dec_1, &dec_2, &sign_2);
return c;
}
int compareTime(int a, int b)
{
int t;
if (a >= b)
{
t = a;
}
else
{
t = b;
}
return t;
}
struct Time run(void)
{
/*各种定义声明*/
SOCKET server;
SOCKET client;
struct sockaddr_in serveraddr;
struct sockaddr_in clientaddr;
WSADATA wsaData;
struct Time allTime;
int len = sizeof(struct sockaddr_in);
int exeTime, serverTime_i, clientTime_i, ret, ret_time_server, ret_time_client;
int t = T, waitTime;
int mode, i;
char receiveData[MAXDATA];
char runData[MAXDATA];
char byeData[MAXDATA];
char serverTime_c[MAXDATA], *serverTime_c_server, clientTime_c[MAXDATA], *clientTime_c_client;
double serverTime_d, clientTime_d;
clock_t startTime, endTime; /*定义计时变量*/
struct timeval start, end, allowstart, allowend, waitstart, waitend, exestart, exeend, calstart, calend;
long int allowSum = 0, exeSum = 0, calSum = 0, waitSum = 0, runSum = 0;
int waitTime_0[MAX_RUN];
/*微妙计时开始*/
gettimeofday(&start, NULL);
mode = modeChoose();
/*服务端*/
if (mode == 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 = creatSocket();
bindIP(server, serveraddr);
listenSocket(server);
//printf("Waiting for connection...\n\n");
client = acceptSocket(server, serveraddr);
//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);
for (i = 0; i < MAX_MESSAGE; i++)
{
sendMessage(client, "I'm ready !", 11);
receiveMessage(client);
}
/*微妙计时结束，计算消息时间*/
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);
/*微妙计时开始*/
gettimeofday(&allowstart, NULL);
/*发：第一次握手*/
sendMessage(client, "First:Run !", 11);
/*收：第二次握手*/
runData[MAXDATA] = receiveMessage(client);
if (strcmp(runData, "Second:Run !") == 0)
{
/*发：第三次握手*/
sendMessage(client, "Third:Run !", 11);
/*微妙计时结束，计算运行时间*/
gettimeofday(&allowend, NULL);
allTime.allowTime[i] = 1000000 * (allowend.tv_sec - allowstart.tv_sec) + allowend.tv_usec - allowstart.tv_usec;
allowSum = allowSum + allTime.allowTime[i];
/*运行时间大于周期时间，则直接运行运行*/
if (t >= T)
{
/*微妙计时开始*/
gettimeofday(&exestart, NULL);
/*计时开始*/
startTime = clock();
exe();
/*计时结束*/
endTime = clock();
/*微妙计时结束，计算运行时间*/
gettimeofday(&exeend, NULL);
allTime.exeTime[i] = 1000000 * (exeend.tv_sec - exestart.tv_sec) + exeend.tv_usec - exestart.tv_usec;
exeSum = exeSum + allTime.exeTime[i];
/*微妙计时开始*/
gettimeofday(&calstart, NULL);
/*服务端运行用时*/
serverTime_d = (double)(endTime - startTime);
//printf("serverTime_d=%ld\n", serverTime_d);
//printf("exeTime=%ld\n", allTime.exeTime[i] / 1000);
serverTime_c_server = charChange(serverTime_d);
sendMessage(client, serverTime_c_server, strlen(serverTime_c_server));
clientTime_c[MAXDATA] = receiveMessage(client);
/*字符串转整形*/
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);
t = compareTime(serverTime_i, clientTime_i);
//printf("The whole system's operation time is %d\n\n", t);
/*微妙计时结束，计算运行时间*/
gettimeofday(&calend, NULL);
allTime.calTime[i] = 1000000 * (calend.tv_sec - calstart.tv_sec) + calend.tv_usec - calstart.tv_usec;
calSum = calSum + allTime.calTime[i];
/*运行总时长小于周期时间，挂起*/
if (t <= T)
{
waitTime_0[i] = T - t - (allTime.calTime[i] + allTime.allowTime[i]) / 1000;
Sleep(waitTime_0[i]);
t = T;
allTime.waitTime[i] = waitTime_0[i] * 1000;
waitSum = waitSum + allTime.waitTime[i];
/*gettimeofday(&waitstart, NULL);
waitTime = T - t - (allTime.calTime[i] + allTime.allowTime[i]) / 1000;
Sleep(waitTime);
t = T;
gettimeofday(&waitend, NULL);
allTime.waitTime[i] = 1000000 * (waitend.tv_sec - waitstart.tv_sec) + waitend.tv_usec - waitstart.tv_usec;
waitSum = 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;
runSum = runSum + allTime.runTime[i];
}
closesocket(server);
WSACleanup();
printf("modeTime=%ld, connectTime=%ld, messageTime=%ld\n", allTime.modeTime, allTime.connectTime, allTime.messageTime);
printf("allowTime=%ld, exeTime=%ld, calTime=%ld, waitTime=%ld\n\n", allowSum / MAX_RUN, exeSum / MAX_RUN, calSum / MAX_RUN, waitSum / MAX_RUN);
//printf("runTime=%ld\n\n", runSum / MAX_RUN);
}
/*客户端*/
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 = creatSocket();
/*绑定IP和端口*/
clientaddr.sin_family = AF_INET; /*定义家族协议*/
clientaddr.sin_addr.s_addr = inet_addr("127.0.0.1"); /*定义主机地址*/
clientaddr.sin_port = htons(PORT); /*定义主机端口*/
connentSocket(client, clientaddr);
/*微妙计时结束，计算连接时间*/
gettimeofday(&end, NULL);
allTime.connectTime = 1000000 * (end.tv_sec - start.tv_sec) + end.tv_usec - start.tv_usec;
/*微妙计时开始*/
gettimeofday(&start, NULL);
for (i = 0; i < MAX_MESSAGE; i++)
{
receiveMessage(client);
sendMessage(client, "I'm ready too !", 15);
}
/*微妙计时结束，计算消息时间*/
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);
/*微妙计时开始*/
gettimeofday(&allowstart, NULL);
/*收：第一次握手*/
runData[MAXDATA] = receiveMessage(client);
if (strcmp(runData, "First:Run !") == 0)
{
/*发：第二次握手*/
sendMessage(client, "Second:Run !", 12);
}
/*收：第三次握手*/
runData[MAXDATA] = receiveMessage(client);
/*微妙计时结束，计算运行时间*/
gettimeofday(&allowend, NULL);
allTime.allowTime[i] = 1000000 * (allowend.tv_sec - allowstart.tv_sec) + allowend.tv_usec - allowstart.tv_usec;
allowSum = allowSum + allTime.allowTime[i];
if (strcmp(runData, "Third:Run !") == 0)
{
/*运行时间大于周期时间，则直接运行运行*/
if (t >= T)
{
/*微妙计时开始*/
gettimeofday(&exestart, NULL);
/*计时开始*/
startTime = clock();
exe();
/*计时结束*/
endTime = clock();
/*微妙计时结束，计算运行时间*/
gettimeofday(&exeend, NULL);
allTime.exeTime[i] = 1000000 * (exeend.tv_sec - exestart.tv_sec) + exeend.tv_usec - exestart.tv_usec;
exeSum = exeSum + allTime.exeTime[i];
/*微妙计时开始*/
gettimeofday(&calstart, NULL);
/*客户端运行用时*/
clientTime_d = (double)(endTime - startTime);
clientTime_c_client = charChange(clientTime_d);
sendMessage(client, clientTime_c_client, strlen(clientTime_c_client));
serverTime_c[MAXDATA] = receiveMessage(client);
/*字符串转整形*/
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);
t = compareTime(serverTime_i, clientTime_i);
//printf("The whole system's operation time is %d\n\n", t);
/*微妙计时结束，计算运行时间*/
gettimeofday(&calend, NULL);
allTime.calTime[i] = 1000000 * (calend.tv_sec - calstart.tv_sec) + calend.tv_usec - calstart.tv_usec;
calSum = calSum + allTime.calTime[i];
/*运行总时长小于周期时间，挂起*/
if (t <= T)
{
waitTime_0[i] = T - t - (allTime.calTime[i] + allTime.allowTime[i]) / 1000;
Sleep(waitTime_0[i]);
t = T;
allTime.waitTime[i] = waitTime_0[i] * 1000;
waitSum = waitSum + allTime.waitTime[i];
/*gettimeofday(&waitstart, NULL);
waitTime = T - t - (allTime.calTime[i] + allTime.allowTime[i]) / 1000;
Sleep(waitTime);
t = T;
gettimeofday(&waitend, NULL);
allTime.waitTime[i] = 1000000 * (waitend.tv_sec - waitstart.tv_sec) + waitend.tv_usec - waitstart.tv_usec;
waitSum = 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;
runSum = runSum + allTime.runTime[i];
}
closesocket(client);
WSACleanup();
printf("modeTime=%ld, connectTime=%ld, messageTime=%ld\n", allTime.modeTime, allTime.connectTime, allTime.messageTime);
printf("allowTime=%ld, exeTime=%ld, calTime=%ld, waitTime=%ld\n\n", allowSum / MAX_RUN, exeSum / MAX_RUN, calSum / MAX_RUN, waitSum / MAX_RUN);
//printf("runTime=%ld\n\n", runSum / MAX_RUN);
}
return allTime;
}
int main(void)
{
/*各种定义*/
struct Time pTime[MAX_MAIN];
int i, j, k, l;
long int modeTimeMax, connectTimeMax, messageTimeMax, allowTimeMax, exeTimeMax, calTimeMax, waitTimeMax, runTimeMax;
long int modeTimeSum, connectTimeSum, messageTimeSum, allowTimeSum, exeTimeSum, calTimeSum, waitTimeSum, runTimeSum;
long int modeTimeAve, connectTimeAve, messageTimeAve, allowTimeAve, exeTimeAve, calTimeAve, 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, allowTimeMax = 0; k < MAX_MAIN; k++)
{
for (l = 0; l < MAX_RUN; l++)
{
if (allowTimeMax < pTime[k].allowTime[l])
{
allowTimeMax = pTime[k].allowTime[l];
}
}
}
/*计算执行算法的最大时间*/
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, calTimeMax = 0; k < MAX_MAIN; k++)
{
for (l = 0; l < MAX_RUN; l++)
{
if (calTimeMax < pTime[k].calTime[l])
{
calTimeMax = pTime[k].calTime[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, allowTimeSum = 0; k < MAX_MAIN; k++)
{
for (l = 0; l < MAX_RUN; l++)
{
allowTimeSum += pTime[k].allowTime[l];
}
}
allowTimeAve = allowTimeSum / (MAX_MAIN * MAX_RUN);
/*计算执行算法的平均时间*/
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, calTimeSum = 0; k < MAX_MAIN; k++)
{
for (l = 0; l < MAX_RUN; l++)
{
calTimeSum += pTime[k].calTime[l];
}
}
calTimeAve = calTimeSum / (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("allowTimeMax=%ld, allowTimeAve=%ld\n", allowTimeMax, allowTimeAve);
printf("exeTimeMax=%ld, exeTimeAve=%ld\n", exeTimeMax, exeTimeAve);
printf("calTimeMax=%ld, calTimeAve=%ld\n", calTimeMax, calTimeAve);
printf("waitTimeMax=%ld, waitTimeAve=%ld\n", waitTimeMax, waitTimeAve);
//printf("runTimeMax=%ld, runTimeAve=%ld\n", runTimeMax, runTimeAve);
Sleep(10000000000);
return 0;
}
收获：
- 模式控制可以用BOOL来实现，比如
BOOL hasMsg = FALSE;
statement1
if (!hasMsg)
{
statement2
}
- “error LNK2019: 无法解析的外部符号”这个错误有可能是不同版本的vs之间不兼容造成的，在当前版本的vs下重建一个项目，然后把代码复制过去，就可以解决这个问题
- 所有数组，只有在定义时才能初始化，其他时候的初始化都是错的