tp.c

calculate throughput

 /* gput.c: out.tr¤ò²òÀϤ·¤Æ¥¹¥ë¡¼¥×¥Ã¥ÈÆÃÀ­¤ò·×»»¤¹¤ë
  *         out.et¤ò²òÀϤ·¤ÆºÆÁ÷¥¿¥¤¥à¥¢¥¦¥È¤ÎȯÀ¸Í­Ìµ¤ò³Îǧ¤¹¤ë
  *   gput <trace file> <event trace file > <required node> <granlarity>
  *   (e.g.,) ./gput out.tr out.et 1 1.0 > goodput.dat
  *   last line output: <goodput>Mbps <isIncast> <transmitted bytes>Byte \
  *              <transmission time>s <first_recv_time>s <last_recv_time>s
  *   <isIncast>: 0 = fales (not incast); 1 = true (incast)
  */

 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>

 #define MAXFLOW 128
 #define SW_NODE 0

 typedef struct rcvd_t {
   int seqno;
   int flow_id;
   struct rcvd_t *next;
 } rcvd_t;

 rcvd_t head;

 int isnew (int seqno, int flow_id)
 {
   rcvd_t *rcvd = head.next;

   while ( rcvd ){
     if ( rcvd->seqno == seqno && rcvd->flow_id == flow_id ) return ;
     rcvd = rcvd->next;
   }

   // true
   return ;
 }

 void updatercvd (int seqno, int flow_id)
 {
   rcvd_t *rcvd;

   if ( NULL == (rcvd = (rcvd_t *)malloc(sizeof(rcvd_t))) ) {
     fprintf(stderr, "Memory Allocation Error.\n");
     exit();
   }

 rcvd->seqno = seqno;
   rcvd->flow_id = flow_id;
   rcvd->next = head.next;
   head.next = rcvd;
 }

 void freercvd (rcvd_t *rcvd)
 {
   if (rcvd->next) freercvd(rcvd->next);
   free(rcvd);
   rcvd = NULL;
 }

 int main ( int argc, char **argv )
 {
   FILE *fp_ns, *fp_et;
   int tx, rx, packet_size, flow_id, sequence, packet_id,
        node, cwnd;
   unsigned long int sum,sum_all;
   char buffer[], event, packet_type[], flags[], tx_address[],
        rx_address[], event_type[], is_rto;
   double time, clock, granularity, first_recv_time, last_recv_time, throughput;
   double last_sent_time[MAXFLOW];

   // Init
   head.next = NULL;
   first_recv_time = 100000.0;
   last_recv_time  = -1.0;
   int i;
   for(i = ; i < MAXFLOW; i++) last_sent_time[i] = -1.0;

   // Open Trace file (out.ns)
   if ( NULL == ( fp_ns = fopen ( argv[], "r" ) ) ) {
     fprintf ( stderr, "Can't open %s\n", argv[] );
     return ;
   }

   // Open Event Trace file (out.et)
   if ( NULL == ( fp_et = fopen ( argv[], "r" ) ) ) {
     fprintf ( stderr, "Can't open %s\n", argv[] );
    return ;
   }

   node = atoi ( argv[] );
   granularity = atof ( argv[] );

   // Goodput Calculation
   for ( sum = , sum_all = , clock = 0.0; feof ( fp_ns ) == ; ) {
     /* 1¹Ôʬ¤Î¥Ç¡¼¥¿¤ò²òÀÏ */
     fgets ( buffer, , fp_ns );
     sscanf ( buffer, "%c %lf %d %d %s %d %s %d %s %s %d %d",
          &event, &time, &tx, &rx, packet_type, &packet_size, flags, &flow_id,
          tx_address, rx_address, &sequence, &packet_id );

     /* ³ºÅö¤¹¤ë¥Ç¡¼¥¿¥é¥¤¥ó¤«³Îǧ¤¹¤ë */
     // exception check
     if ( flow_id >= MAXFLOW ) {
             printf("MAXFLOW ERROR! flow_id:%d\n", flow_id);
             return ;
     }

     // for counting retransmission timeout
     if ( event == '+' && rx == SW_NODE
          && last_sent_time[flow_id] < time )
             last_sent_time[flow_id] = time;

     // for calculating goodput
     if ( event != 'r' ) continue;
     if ( strcmp(packet_type, "tcp") !=  ) continue;
     if ( rx != node )   continue;

     /* ¥¹¥ë¡¼¥×¥Ã¥È¤Î·×»» Mbps*/
     if ( ( time - clock ) > granularity ) {
         throughput = ( (double) sum / granularity ) * 8.0 / 1000.0 / 1000.0;
         clock += granularity;
         printf ( "%f\t%f\t%d\n", clock, throughput, sum );
         sum = ;
     }

     // is newdata? (uncount unnecessary restransmission)
     if ( isnew(sequence, flow_id) ){
       updatercvd(sequence, flow_id);
       if ( first_recv_time > time) first_recv_time = time;
       last_recv_time = time;
       sum     += packet_size;
       sum_all += (unsigned long int)packet_size;
     }
   } // for

   throughput = ( (double) sum_all / (last_recv_time - first_recv_time) )
                                                     * 8.0 / 1000.0 / 1000.0;

   // Count Retransmisson Timeout Event from Event Trace file
   for ( is_rto = ; feof ( fp_et ) == ; ) {
     /* 1¹Ôʬ¤Î¥Ç¡¼¥¿¤ò²òÀÏ */
     fgets ( buffer, , fp_et );
     sscanf ( buffer, "%c %lf %d %d %s %s %d %d %d",
          &event, &time, &tx, &rx, packet_type, event_type, &flow_id,
          &sequence, &cwnd );

     if ( time > last_sent_time[flow_id] ) continue;
     if ( strcmp(event_type, "TIMEOUT") ==  ) is_rto = ;
   }

   printf ( "%f\t%d\t%u\t%f\t%f\t%f\n",
            throughput, is_rto, sum_all, last_recv_time - first_recv_time,
            first_recv_time, last_recv_time);

   fclose ( fp_ns );
   fclose ( fp_et );

   freercvd( head.next );

   return ;
 }