Software Functionality Overview

Server Option 1:

Figure 1 Interarrival Time Calculation used in arr_serv.c

• Total number of packets received
• Mean interarrival time for all received packets
• Minimum interarrival time
• Maximum interarrival time
• Standard deviation about the mean interarrival time Additionally, the program writes to a text file called “arrData.txt” with the calculated interarrival times such that they may be plotted. Each time the program is executed, the old data is overwritten with new data.

  Server Option 2:

  The second option is to establish the server delta_serv.c on the target machine. This server will calculate the difference between when a UDP packet is generated on the client machine and when it is finally received on the target machine. The transmission time corresponds the difference between the time stamp which is set by the sender (client) at the time of UDP packet creation and the time on the target machine (server) when the UDP packet is received. Note that the clocks will likely not be synchronized and there is a possibility that the mean transmission time may be negative. This is still a useful measurement because the deviation about the mean (even if negative) will indicate the smoothing characteristics of applied filters or metering devices.

  

  Figure 2. Interarrival Time Calculation used in arr_serv.c

  The output from delta_serv.c to the screen is:
• Total number of packets received
• Mean transmission time for all received packets
• Minimum transmission time
• Maximum transmission l time
• Standard deviation about the mean transmission time Additionally, the program writes to a text file called “deltaData.txt” with the calculated transmission times such that they may be plotted. Note that each time the program is executed, the old data is overwritten with new data.

  Software Architecture Overview:

  The UDP client is designed to send messages to one of two servers. The first server “arr_serv.c” is designed to receive UDP packets from any host and closes its socket when a UDP packet is received with the characters “END” in it. The software interactions are depicted in Figure 3.

  

  Figure 3 – Schematic Overview of Client / Server for Interarrival Time

  The second server “delta_serv.c” is designed to receive UDP packets from any host executing UDP_cli.c and closes its socket when a UDP packet is received with the characters “END” in it. The software interactions are depicted in Figure 4.

  

  Figure 4 – Schematic Overview of Client / Server for Transmission Time

  Assembly Code for Accessing Processor Clock Ticks

  If a finer granularity than millionths of a second is required, the assembly provided in Attachment 4 can be used to access individual central processor “clock ticks.” The “ticks” will have to be calibrated for the speed of a given processor in order to correlate the number of clock ticks which corresponds to a millisecond. The assembly code can be embedded into either of the client programs with the “asm {}” form or other. This was beyond the scope of the tools to be provided for this assignment but this code is provided for future use if needed. The code was obtained through a contact at the General Electric Corporate Research and Development Center – the author is unknown.

  Operating Instructions:

  Modify the header file dc_const.h to customize the program to suit testing needs: Determine how many UDP packets to send via the LOOP parameter Set the IP address for the target machine (receiver or server) via the CLIENT_IP parameter Note that you must recompile the clients and server after modifying the header file.

  Server (Target) Machine Operation:

  The server must be executed first so that it is in “listening mode” and waiting to receive transmissions from the client. The server may be started only after the client is a waiting mode. Place the following files into a single directory on the server machine:
• arr_serv.c
• delta_serv.c
• dc_const.h (only needed if recompiling on this machine)

  Launch the first server by typing: ./arr_serv

  - Or - launch the second server by typing: ./delta_serv

  The server will also generate a text file which is written to each time the program is executed. The file is called “arrData.txt” for the first server option and “deltaData.txt” for the second server option. “arrData.txt” contains a list of the time stamp of each UDP packet arrival relative to the server or target machine’s clock. “deltaData.txt” contains a list of the difference in time between when the UDP packet was received (relative to the target or server’s clock) and when the packet was sent (relative to the sender or client’s clock).

  Please note that the text files "arrData.txt" and "deltaData.txt" are written to the process owner's home directory. There is a commented-out section of code to write the text files to the local machine's "tmp" directory. The author did not have permission to write to the "tmp" directory and had to write to his home directory. Writing to the home directories can impact the quality of the measured data because each write to the text file will generte network traffic. For most accurate results, write to the "tmp" directory if you have permission.

  Client Machine (Sender) Operation:

  Place the following files into a single directory on the client machine:

• UDP_cli.c
• dc_const.h (only needed if recompiling on this machine)

  compile the source code with: gcc –o UDP_cli UDP_cli.c

  execute the client with: ./UDP_cli

  After LOOP number of UDP packets have been sent, the command line prompt will be returned.

  Attachment 1 – Client Source Code “UDP_cli.c”

  
  // Source code UDP_cli.c
  // Written by Darren Challey
  // Rensselaer Polytechnic Institute
  // Spring 2000
  
  // UDP Client used to generate UDP packets for measuring packet
  // shaper performance and smoothing characteristics. UDP packets
  // are sent to one of two server programs: arr_serv.c or delta_serv.c
  // based upon programs found in "Unix Network Programming" - Stevens
  
  
  #include "netinet/in.h" // needed for sockaddr_in struct p58
  #include // Needed for timeval
  #include // Needed for error handling function
  #include "dc_const.h" // Needed for constants and loop iterations
  
  int main()
  {
  
  int sockfd; // socket file descriptor
  int errno; // Error code
  int x = 1; // counter
  int a; // counter
  char buff[MAXLINE]; // send buffer
  char end[MAXLINE]; // last sent character
  long tm; // current time
  struct sockaddr_in servaddr; //
  struct sockaddr_in cliaddr; //
  struct timeval tv; //
  int sec; // current time - seconds
  double mic; // current time - microseconds
  
  // Initiaize the character arrays
  for(a = 0; a < MAXLINE; a++) {
  buff[a] = ' ';
  end[a] = ' ';
  }
  
  // The following buffer of characters will be sent last
  end[0] = 'E';
  end[1] = 'N';
  end[2] = 'D';
  
  buff[MAXLINE - 1] = '\n'; // New Line
  end[MAXLINE - 1] = '\n' ; // New Line
  
  sockfd =socket(AF_INET, SOCK_DGRAM, 0);
  
  printf("\nStarting Client Process\n");
  bzero(&servaddr, sizeof(servaddr));
  servaddr.sin_family = AF_INET;
  servaddr.sin_addr.s_addr = inet_addr(SERVER_IP); //set in dc_const.h
  servaddr.sin_port = htons(52330);
  
  printf(CLIENT_IP);
  
  if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0 ) {
  printf("Could not create socket.");
  }
  
  printf("\nsockfd =%d", sockfd);
  // errno = connect(sockfd, (struct sockaddr *) &servaddr, sizeof(servaddr));
  
  // if (errno < 0) {printf("\nConnection Failed\n");}
  // printf("\nerrno =%d", errno);
  
  while(x <= LOOP) {
  
  gettimeofday(&tv, NULL); // p 512, 551
  sec = tv.tv_sec;
  mic = tv.tv_usec / 1000000.0;
  snprintf(buff, sizeof(buff), "%f", sec + mic);
  sendto(sockfd, buff, MAXLINE, 0, &servaddr, sizeof(servaddr));
  printf("\nUDP pkt %u sent at %s seconds", x, buff);
  
  x++;
  
  } // End of Loop
  
  sendto(sockfd, end, MAXLINE, 0, &servaddr, sizeof(servaddr));
  sendto(sockfd, end, MAXLINE, 0, &servaddr, sizeof(servaddr));
  // why is the last datagram never received?
  
  printf("\n\n");
  
  } // End Main

  Attachment 2 – Server Source Code “arr_serv.c”

  
  // Source code arr_serv.c
  // Written by Darren Challey
  // Rensselaer Polytechnic Institute
  // Spring 2000
  
  // This server is to be used to determine the smoothing characteristics
  // of traffic shapers. It determines mean, min, max, and standard
  // deviation of arrival times
  // Based upon programs found in "UNIX Network Programming" - Stevens
  
  #include
  #include "netinet/in.h" // Needed for sockaddr_in struct
  #include // Needed for timeval
  #include // Needed for file I/O
  #include // Needed for error function
  #include "dc_const.h" // Needed for program constants
  
  int main()
  {
  // Open a file to write data
  FILE *arrData;
  
  int sockfd = 0; // socket file descriptor
  int in = 0; // input received from socket
  int a = 0;
  char msg[MAXLINE];
  double arrive[LOOP + 1];
  double delta[LOOP + 1];
  double mean_sum = 0.0;
  double mean = 0.0;
  double std_sum = 0.0;
  double diff = 0.0;
  double std_dev = 0.0;
  double min = 10.0;
  double max = 0.0;
  int count = 0;
  int sec = 0;
  double mic = 0.0;
  struct sockaddr_in servaddr;
  struct sockaddr_in cliaddr;
  struct timeval tv;
  
  // Initialization
  for (a = 0; a < MAXLINE; a++) {
  msg[a] = ' ';
  }
  arrive[0] = 0; // Array element not used
  delta[0] = 0; // Array element not used
  
  
  printf("\nStarting Server\n");
  
  
  if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
  perror("No Socket");
  printf("errno = %d.", errno); // p475
  exit(1);
  }
  
  // If socket is successful, sockfd will be a small positive integer
  // arrData = fopen("/tmp/arrData.txt", "w+");
  arrData = fopen("arrData.txt", "w+");
  // w = write-enabled, + will allow file to be overwritten
  
  bzero(&servaddr, sizeof(servaddr)); // set entire structure to 0
  servaddr.sin_family = AF_INET; // set family to IPV4
  servaddr.sin_addr.s_addr = CLIENT_IP; // set in dc_const.h
  servaddr.sin_port = htons(52330); // randomly selected ephemeral
  // ports as being 49152 to 65535
  if ( bind(sockfd, (struct sockaddr*) &servaddr, sizeof(servaddr)) < 0 )
  {
  printf( "bind failed" );
  exit(1);
  }
  else printf("\nBind Successful\n");
  
  // Read information from the socket
  in = recvfrom(sockfd, msg, MAXLINE, 0, NULL, NULL);
  
  while(msg[0] != 'E') { // Loop until last datagram received
  
  count++;
  
  // Determine arrival time
  gettimeofday(&tv, NULL);
  sec = tv.tv_sec;
  mic = tv.tv_usec / 1000000.0;
  arrive[count] = (double)sec + mic;
  
  // Print arrival time to the screen and file
  printf("\ntime arrived: %f", arrive[count]);
  fprintf(arrData, "%f\n", arrive[count]);
  
  // Read information from the socket
  in = recvfrom(sockfd, msg, MAXLINE, 0, NULL, NULL);
  
  } // End of Loop while not last datagram
  
  
  // OUTPUT OF RESULTS ////////////////////////////////////////
  
  printf("\n\nTotal Packets Rec'd = %d", count);
  
  // Calculate the mean time of arrivals
  for (a = 2; a < LOOP + 1; a++) {
  delta[a] = arrive[a] - arrive[a - 1];
  mean_sum += delta[a];
  if (delta[a] > max) max = delta[a];
  if (delta[a] < min) min = delta[a];
  }
  
  mean = mean_sum / ((double)LOOP - 1.0);
  printf("\nMean interarrival time = %f", mean);
  
  // Calculate Standard Deviation
  for (a = 2; a < LOOP + 1; a++) {
  diff = mean - delta[a];
  std_sum += diff * diff;
  }
  
  std_dev = std_sum / ((double)LOOP - 1.0);
  printf("\nMinimum interarrival time = %f", min);
  printf("\nMaximum interarrival time = %f", max);
  printf("\nStandard Deviation = %E", std_dev);
  
  fclose(arrData);
  printf("\n\n");
  
  } // End Main

  Attachment 3 – Server Source Code “delta_serv.c”

  
  // Source code delta_serv.c
  // Written by Darren Challey
  // Rensselaer Polytechnic Institute
  // Spring 2000
  
  // This server is to be used to determine the smoothing characteristics
  // of traffic shapers. It determines mean, min, max, and standard
  // deviation of the difference in time between the senders clock and
  //
  // Based upon programs found in "UNIX Network Programming" - Stevens
  
  #include
  #include "netinet/in.h" // needed for th sochaddr_in struct
  #include // Needed for timeval
  #include // Needed for file I/O
  #include // Needed for error function
  #include "dc_const.h" // Needed for program constants
  
  int main()
  {
  // Open a file to write data
  FILE *deltaData;
  
  int sockfd = 0; // socket file descriptor
  int in = 0; // input received from socket
  int a = 0;
  char msg[MAXLINE];
  double arrive[LOOP + 1];
  double diff[LOOP + 1];
  double sent = 0.0;
  double mean_sum = 0.0;
  double mean = 0.0;
  double std_sum = 0.0;
  double difference = 0.0;
  double std_dev = 0.0;
  double min = 10.0;
  double max = 0.0;
  int count = 0;
  int sec = 0;
  double mic = 0.0;
  struct sockaddr_in servaddr; // p58
  struct sockaddr_in cliaddr; // p58
  struct timeval tv;
  
  // Initialization
  for (a = 0; a < MAXLINE; a++) {
  msg[a] = ' ';
  }
  arrive[0] = 0; // Array element not used
  
  printf("\nStarting Server\n");
  
  if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
  perror("No Socket");
  printf("errno = %d.", errno); // p475
  exit(1);
  }
  
  // If socket is successful, sockfd will be a small positive integer
  // deltaData = fopen("/tmp/deltaData.txt", "w+");
  deltaData = fopen("deltaData.txt", "w+");
  // w = write-enabled, + will allow file to be overwritten
  
  bzero(&servaddr, sizeof(servaddr)); // set entire structure to 0
  servaddr.sin_family = AF_INET; // set family to IPV4
  servaddr.sin_addr.s_addr = CLIENT_IP; // set in dc_const.h
  servaddr.sin_port = htons(52330); // randomly selected ephemeral
  // ports as being 49152 to 65535
  if ( bind(sockfd, (struct sockaddr*) &servaddr, sizeof(servaddr)) < 0 )
  {
  printf( "\nBind Failed\n" );
  exit(1);
  }
  else printf("\nBind Successful\n");
  
  // Read information from the socket
  in = recvfrom(sockfd, msg, MAXLINE, 0, NULL, NULL);
  
  while(msg[0] != 'E') { // Loop until last datagram received
  
  count++;
  
  // Determine arrival time
  gettimeofday(&tv, NULL);
  sec = tv.tv_sec;
  mic = tv.tv_usec / 1000000.0;
  arrive[count] = (double)sec + mic;
  
  // Convert incoming message from char string to double
  sent = atof(msg);
  
  // Subtract time stamp from client (sender) from current time on server
  diff[count] = arrive[count] - sent;
  
  // Print transit time to the screen and file
  printf("\n%u transit time: %f %f", count, diff[count], arrive[count]);
  fprintf(deltaData, "%f\n", diff[count]);
  
  // Read information from the socket
  in = recvfrom(sockfd, msg, MAXLINE, 0, NULL, NULL);
  
  } // End of Loop when last datagram received
  
  // OUTPUT OF RESULTS ////////////////////////////////////////
  
  printf("\n\nTotal Packets Rec'd = %d", count);
  
  // Calculate the mean time of arrivals
  for (a = 2; a < LOOP; a++) {
  mean_sum += diff[a];
  if (diff[a] > max) max = diff[a];
  if (diff[a] < min) min = diff[a];
  }
  
  mean = mean_sum / ((double)LOOP - 1.0);
  printf("\nMean transit time = %f", mean);
  
  // Calculate Standard Deviation
  for (a = 2; a < LOOP + 1; a++) {
  difference = mean - diff[a];
  std_sum += difference * difference;
  }
  
  std_dev = std_sum / ((double)LOOP - 1.0);
  printf("\nMinimum transit time = %f", min);
  printf("\nMaximum transit time = %f", max);
  printf("\nStandard Deviation = %E", std_dev);
  
  fclose(deltaData);
  printf("\n\n");
  
  } // End Main

  Attachment 4 - Header File “dc_const.h”

  
  // Header file for UDP_cli.c, arr_serv.c and delta_serv.c
  // Written by Darren Challey
  // Rensselaer Polytechic Institute
  // Spring Term 2000
  
  #define MAXLINE 32 // Number of characters in UDP message
  
  #define LOOP 500 // Number of UDP datagrams to send
  
  #define SERVER_IP "128.113.51.98" // IP address of the server (receiver)
  
  #define CLIENT_IP INADDR_ANY // IP address of the client (sender)

  Attachment 5 - Assembly Language Source Code "rdtsc.s" for accessing processor clock cycles

  
  /* */
  /* This routine reads the pentium cycle counter and */
  /* returns the 64 bit cycle count to the caller. */
  /* */
  /* void rdtsc(long long* pCycleCount) */
  /* or */
  /* This routine can read the cycle count if using gcc under linux
  /* Add the rdtsc.s file to your compile and it effectively creates
  /* a runtime rdtsc that takes either a long long* or a long[2]
  /* can add this section of assembly to C code with ASM {}
  
  /* void rdtsc(long[2] cycleCount) */
  /* */
  .file "rdtsc.s"
  gcc2_compiled.:
  ___gnu_compiled_c:
  .text
  .align 4
  .globl _rdtsc
  _rdtsc:
  pushl %ebp /* save old call frame */
  movl %esp,%ebp /* create a call frame */
  pushl %eax /* save volatile registers */
  pushl %ebx /* rdtsc destroys eax and edx */
  pushl %edx /* we use ebx to get argument address */
  rdtsc /* read the cycle counter */
  movl 8(%ebp),%ebx /* ebx <== address of result */
  movl %eax,(%ebx) /* return least significant 32 bits */
  movl %edx,4(%ebx) /* return most significant 32 bits */
  popl %edx /* restore volatile registers */
  popl %ebx
  popl %eax
  movl %ebp,%esp /* remove call frame */
  popl %ebp /* restore old call frame */
  ret /* return to caller */