receiver.c

adhoc 下网络带宽测试代码 linux下C源码

    /*
    ** listener.c -- a datagram sockets "server" demo
    */

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <unistd.h>
    #include <errno.h>
    #include <string.h>
    #include <sys/time.h>
    #include <sys/types.h>
    #include <sys/socket.h>
    #include <netinet/in.h>
    #include <arpa/inet.h>

    #define MYPORT 15000    // the port users will be connecting to

    #define MAXBUFLEN 100000
    
    #define HEADER_SIZE 28

//#define CPU_HZ 501125000

    __inline__ unsigned long long rdtsc(){
            unsigned long long int x;
                 __asm__ volatile (".byte 0x0f, 0x31" : "=A" (x));
                      return x;
    }


unsigned long long CPU_HZ = 0;
double cap_rtt1[10000];
double cap_rtt2[10000];
double cap_C;
double cap_RTT;
double px[5000];
double py[5000];
double pd[5000];
double pi[5000];

double px1[5000];
double py1[5000];
double pd1[5000];
double pi1[5000];

int num = 0;
FILE *in;

    int main(void)
    {
        int sockfd;
        struct sockaddr_in my_addr;    // my address information
        struct sockaddr_in their_addr; // connector's address information
        int addr_len, numbytes;
        char buf[MAXBUFLEN];
	int *DATA;
	int run = 1;

        if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) == -1) {
            perror("socket");
            exit(1);
        }

        my_addr.sin_family = AF_INET;         // host byte order
        my_addr.sin_port = htons(MYPORT);     // short, network byte order
        my_addr.sin_addr.s_addr = INADDR_ANY; // automatically fill with my IP
        memset(&(my_addr.sin_zero), '\0', 8); // zero the rest of the struct

        if (bind(sockfd, (struct sockaddr *)&my_addr,
                                              sizeof(struct sockaddr)) == -1) {
            perror("bind");
            exit(1);
        }

        addr_len = sizeof(struct sockaddr);

{
//--------------------------------
//  read /proc/cpuinfo information
//

FILE *Proc;
char buf[300];
char buf2[300];


Proc = fopen("/proc/cpuinfo","r");
while(fgets(buf,255,Proc)){
	if (strstr(buf,"cpu MHz")){
		buf[strlen(buf)-1]='\0';
		CPU_HZ = atof(buf+11)*1000000;
		break;
	}
}
fclose(Proc);
//--------------------------------
}
	cap_C = 0;
	cap_RTT = 1000000000;

	in = fopen("out","w");
	for(;;){
		int i;

            if ((numbytes=recvfrom(sockfd,buf, MAXBUFLEN-1, 0,
                               (struct sockaddr *)&their_addr, &addr_len)) == -1) {
                perror("recvfrom");
                exit(1);
            }
            numbytes += HEADER_SIZE;

		DATA = buf;

	        i = (DATA[0] - 1)/2;

		if (DATA[0]%2==1){
			double t = (double)rdtsc()/CPU_HZ;
			double * dd = DATA + 1;
			cap_rtt1[i] = t - dd[0];

			fflush(in);
		} else if (cap_rtt1[i]!=0) {
			double t = (double)rdtsc()/CPU_HZ;
			double * dd = DATA + 1;
			double disp, rtt_sum, C, pre_rtt_sum, offset_x, offset_y;
			int trend;
			cap_rtt2[i] = t - dd[0];
			disp = cap_rtt2[i] - cap_rtt1[i];
			rtt_sum = cap_rtt1[i] + cap_rtt2[i];
			if (disp>0) {
				C = (double)(numbytes * 8) / disp / 1000000;  // Mbps

				{
					if (num>0) {
						if (rtt_sum>pre_rtt_sum) trend++;
						else if (rtt_sum<pre_rtt_sum) trend--;
					} else {
						trend = 0;
						offset_y = rtt_sum;
						offset_x = t;
					}
					pre_rtt_sum = rtt_sum;
					px[num] = t - offset_x;
					py[num] = rtt_sum - offset_y;
					pd[num] = disp;
					pi[num] = num;
					px1[num] = t - offset_x;
					py1[num] = cap_rtt1[i];
					pd1[num] = disp;
					pi1[num] = num;
				}
				
				num++;
				if (rtt_sum<cap_RTT) {
					cap_RTT = rtt_sum;
					cap_C = C;
				}
				printf("%d %3.6lf  %3.3lf %3.3lf   %3.9lf  %3.9lf %d\n",num, t, C,cap_C, rtt_sum, cap_rtt1[i], run);
				fprintf(in,"%d %3.6lf  %3.3lf %3.3lf   %3.9lf  %3.9lf %d\n",num, t, C,cap_C, rtt_sum, cap_rtt1[i], run);
			}

			cap_rtt1[i] = 0;
			cap_rtt2[i] = 0;

			if (num>=200) {
				int i,j,k,k1,k_final;
				k = 1;
				k1 = 1;

				printf("%d, =====>cap_C= %3.6lf %3.6lf %3.6lf\n", trend, C, cap_C, cap_C);
				fprintf(in,"%d, =====>cap_C= %3.6lf %3.6lf %3.6lf\n", trend, C, cap_C, cap_C);

				if (trend>=30){  // increasing trend
					for (i=2;i<num;i++) {
						if (py[i]<(py[k]+(py[k]-py[k-1])*(px[i]-px[k])/(px[k]-px[k-1]))) { // p[i] is above the line
							px[k] = px[i];
							py[k] = py[i];
							pd[k] = pd[i];
							pi[k] = pi[i];
						} else {
							k++;
							px[k] = px[i];
							py[k] = py[i];
							pd[k] = pd[i];
							pi[k] = pi[i];
						}
					}
					for (i=2;i<num;i++) {
						if (py1[i]<(py1[k1]+(py1[k1]-py1[k1-1])*(px1[i]-px1[k1])/(px1[k1]-px1[k1-1]))) { // p[i] is above the line
							px1[k1] = px1[i];
							py1[k1] = py1[i];
							pd1[k1] = pd1[i];
							pi1[k1] = pi1[i];
						} else {
							k1++;
							px1[k1] = px1[i];
							py1[k1] = py1[i];
							pd1[k1] = pd1[i];
							pi1[k1] = pi1[i];
						}
					}
				} else if (trend<=-30) { // decreasing trend
					for (i=2;i<num;i++) {
						if (py[i]>(py[k]+(py[k]-py[k-1])*(px[i]-px[k])/(px[k]-px[k-1]))) { // p[i] is above the line
							px[k] = px[i];
							py[k] = py[i];
							pd[k] = pd[i];
							pi[k] = pi[i];
						} else {
							k++;
							px[k] = px[i];
							py[k] = py[i];
							pd[k] = pd[i];
							pi[k] = pi[i];
						}
					}
					for (i=2;i<num;i++) {
						if (py1[i]>(py1[k1]+(py1[k1]-py1[k1-1])*(px1[i]-px1[k1])/(px1[k1]-px1[k1-1]))) { // p[i] is above the line
							px1[k1] = px1[i];
							py1[k1] = py1[i];
							pd1[k1] = pd1[i];
							pi1[k1] = pi1[i];
						} else {
							k1++;
							px1[k1] = px1[i];
							py1[k1] = py1[i];
							pd1[k1] = pd1[i];
							pi1[k1] = pi1[i];
						}
					}
				} else trend = 0;

				if (trend!=0) {
					disp = 0;
					k_final = 0;
					for(i=1,j=1;i<=k,j<=k1;i++,j++){
						for (;j<=k1;j++){
							if (pi[i]==pi1[j]){
								disp += pd[i];
								k_final++;
								printf(" %d %3.9lf  %3.9lf   %3.9lf  %3.6lf\n",i, px[i],py[i],pd[i],(double)(numbytes * 8) / pd[i] / 1000000);
								fprintf(in," %d %3.9lf  %3.9lf   %3.9lf\n",i, px[i],py[i],pd[i]);
								break;
							}
						}
					}
					if (k_final==0) { disp = pd[0]; }
					else {
						disp /= (double)(k_final);
					}
					C = (double)(numbytes * 8) / disp / 1000000;  // Mbps
				} else {
					C = cap_C;
					k_final = -1;
					k = -1;
					k1 = -1;
				}
				printf("==> Capacity = %3.3lf  k= %d  %d  %d\n",C,k_final,k,k1);
				fprintf(in,"==> Capacity = %3.3lf  k= %d  %d  %d\n",C,k_final,k,k1);

				if (trend!=0){
					for(i=1,disp=0;i<=k;i++){
						disp += pd[i];
					}
					disp /= (double)(k);
					C = (double)(numbytes * 8) / disp / 1000000;  // Mbps
				}
				printf("==> CAP = %3.3lf  k= %d  %d  %d\n",C,k_final,k,k1);
				fprintf(in,"==> CAP = %3.3lf  k= %d  %d  %d\n",C,k_final,k,k1);

				cap_C = 0;
				cap_RTT = 1000000000;
				num = 0;
				run++;
			}

		}
        }
	fclose(in);
        close(sockfd);

        return 0;
    }