totals-cbrp.pl

ns2.1b5版本中cbrp碼

#!/usr/bin/perl

#
# Structure of a "log" line.
#
$hdr->{opcode} = 0;
$hdr->{time} = 0;               # Not used by totals
$hdr->{node} = 0;
$hdr->{uid} = 0;                # Not used by totals
$hdr->{logtype} = 0;            # AGT, RTR, MAC
$hdr->{logreason} = 0;
$hdr->{pkttype} = 0;
$hdr->{pktsize} = 0;

my $log_error_fatal = 0;

@ARPTYPE = ("REQUEST", "REPLY");
@TCPTYPE = ("tcp", "ack");
@MACTYPE = ("RTS", "CTS", "ACK");
@TORATYPE = ("BEACON", "HELLO", "HELLO_ACK", "QUERY", "UPDATE", "CLEAR");
@DSRTYPE = ("REQUEST", "REPLY", "ERROR", "CACHED REPLY", "GRAT REPLY");
@AODVTYPE = ("REQUEST", "REPLY", "HELLO", "UNSOLICITED REPLY");
@IMEPTYPE = ("BEACON", "HELLO", "ACK", "OBJECT");
@CBRPTYPE = ("HELLO","REQUEST","REPLY","ERROR","GRAT REPLY(repaired)", "GRAT REPLY(shortened)", "GRAT REPLY(both)", "CACHED REPLY");                  #- added by Jinyang
$MACTYPE_RTS = hex("1b");
$MACTYPE_CTS = hex("1c");
$MACTYPE_ACK = hex("1d");
$MACTYPE_DATA = hex("20");

$infile = 0;			# input file
$time = 0;			# length of the simulation
$line = 0;			# line number of input file

$PACKET_SIZE = 1460;		# Data bytes in a TCP Packet
$MAX_ROUTE_LENGTH = 10;		# Maximum Route Length
$MAX_NODES = 0;			# Number of nodes
$TOTALS = 0;			# Number of nodes + 1;

#
# These are the *main* statistical categories that are used on
# a per-protocol basis.
#
$OP_TX = 1;             # transmit
$OP_RX = 2;             # receive
$OP_FW = 3;             # packet forwards
$OP_DR = 4;             # drops
$OP_ACT_RTLEN = 5;      # array of counts of actual route lengths
$OP_OPT_RTLEN = 6;      # array of counts of optimal route lengths
$OP_DIF_RTLEN = 7;      # array of counts of differences between OPT/ACT
$OP_OVERHEAD = 8;       # Per packet overhead (used by DSR)

#
# Global Subcategories
#
$BCNT = 1;              # byte count
$PCNT = 2;              # packet count
$GLOBAL_MAX = 2;

#
# Subcategories for TX
#
$TX_BCNT = $BCNT;        # Byte Count
$TX_PCNT = $PCNT;        # Packet Count

#
# Subcategories for RX
#
$RX_BCNT = $BCNT;        # Byte Count
$RX_PCNT = $PCNT;        # Packet Count

#
# Subcategories for FW
#
$FW_BCNT = $BCNT;        # Byte Count
$FW_PCNT = $PCNT;        # Packet Count

#
# Subcategories for packet drops at the MAC layer
#
$DR_MAC_COL = $GLOBAL_MAX + 1;          # collision
$DR_MAC_DUP = $GLOBAL_MAX + 2;          # duplicate
$DR_MAC_ERR = $GLOBAL_MAX + 3;          # CRC invalid
$DR_MAC_RET = $GLOBAL_MAX + 4;          # RETRY count exceeded
$DR_MAC_STA = $GLOBAL_MAX + 5;          # invalid state
$DR_MAC_BSY = $GLOBAL_MAX + 6;          # MAC busy

#
# Subcategories for packet drops a the RTR (Routing) layer
#
$DR_RTR_NRT = $GLOBAL_MAX + 1;          # No Route
$DR_RTR_TTL = $GLOBAL_MAX + 2;          # TTL Expired
$DR_RTR_IFQ = $GLOBAL_MAX + 3;          # Router Queue Full
$DR_RTR_TOUT = $GLOBAL_MAX + 4;         # Packet Timed Out in IFQ
$DR_RTR_LOOP = $GLOBAL_MAX + 5;         # Routing Loop
$DR_RTR_MAC_CALLBACK = $GLOBAL_MAX + 6; # Dropped by MAC Callback
$DR_IFQ_FULL = $GLOBAL_MAX + 7;         # Interface Queue Full
$DR_IFQ_ARP = $GLOBAL_MAX + 8;          # Dropped by ARP
$DR_END_SIM = $GLOBAL_MAX + 9;

# ======================================================================
# Initialization Routines
# ======================================================================
sub init_counters {
	my $A = shift(@_);

        $A->[$OP_TX]->[$BCNT] = 0;
        $A->[$OP_TX]->[$PCNT] = 0;

        $A->[$OP_RX]->[$BCNT] = 0;
        $A->[$OP_RX]->[$PCNT] = 0;

        $A->[$OP_FW]->[$BCNT] = 0;
        $A->[$OP_FW]->[$PCNT] = 0;

        $A->[$OP_DR]->[$BCNT] = 0;
        $A->[$OP_DR]->[$PCNT] = 0;

        $A->[$OP_DR]->[$DR_MAC_COL] = 0;
        $A->[$OP_DR]->[$DR_MAC_DUP] = 0;
        $A->[$OP_DR]->[$DR_MAC_ERR] = 0;
        $A->[$OP_DR]->[$DR_MAC_RET] = 0;
        $A->[$OP_DR]->[$DR_MAC_STA] = 0;
        $A->[$OP_DR]->[$DR_MAC_BSY] = 0;

        $A->[$OP_DR]->[$DR_RTR_NRT] = 0;
        $A->[$OP_DR]->[$DR_RTR_TTL] = 0;
        $A->[$OP_DR]->[$DR_RTR_IFQ] = 0;
        $A->[$OP_DR]->[$DR_RTR_TOUT] = 0;
        $A->[$OP_DR]->[$DR_RTR_LOOP] = 0;
	$A->[$OP_DR]->[$DR_RTR_MAC_CALLBACK] = 0;
	$A->[$OP_DR]->[$DR_IFQ_FULL] = 0;
	$A->[$OP_DR]->[$DR_IFQ_ARP] = 0;
	$A->[$OP_DR]->[$DR_END_SIM] = 0;
};

sub init_nodes {
        my $PKT = shift(@_);

        for($n = 1; $n <= $MAX_NODES; $n++) {
		init_counters($PKT->[$n]);
        }
}


sub init_type {

        my $PKT = shift(@_);

        if($PKT eq "CBR") {
                init_nodes(CBR);
        }
        if($PKT eq "DSR") {
	    $deadlink_seen = 0;
	    $reply_sent = 0;
	    $reply_received = 0;
	    $cache_reply_sent = 0;
	    $new_request = 0;
	    $grat_reply_sent = 0;
	    $pkts_salvaged = 0;
        }
      
        # Init CBRP counters
        if ($PKT eq "CBRP") {
            $cbrp_new_request = 0;
            $cbrp_request_broadcast = 0;
            $cbrp_reply_sent = 0;
            $cbrp_cache_reply_sent = 0;
            $cbrp_reply_received = 0;
            $cbrp_pkts_salvaged_localrepair = 0;
            $cbrp_pkts_salvaged_cache = 0;
            $cbrp_pkts_salvaged_request = 0;
            $cbrp_pkts_salvaged_reply = 0;
            $cbrp_pkts_dropped_request = 0;
            $cbrp_pkts_dropped_reply_looped = 0;
            $cbrp_pkts_dropped_reply_no_route = 0;
            $cbrp_pkts_success_route_shortened = 0;
            $cbrp_pkts_wrong_route_shortened = 0;
            $cbrp_pkts_grat_reply_repaired = 0;
            $cbrp_pkts_grat_reply_shortened = 0;
        }
            	

        #
        # Initialize each packet type for PKT.
        #
        foreach $P (@_) {

		init_counters($PKT->{$P});

                for($i = 0; $i <= $MAX_ROUTE_LENGTH; $i++) {
                        $PKT->{$P}->[$OP_ACT_RTLEN]->[$i] = 0;
                        $PKT->{$P}->[$OP_OPT_RTLEN]->[$i] = 0;
                        $PKT->{$P}->[$OP_DIF_RTLEN]->[$i] = 0;
                }
        }

        #
        #  Initialize TOTALS section of PKT
        #
	init_counters($PKT->[$TOTALS]);

        for($i = 0; $i <= $MAX_ROUTE_LENGTH; $i++) {
		$PKT->[$TOTALS]->[$OP_ACT_RTLEN]->[$i] = 0;
                $PKT->[$TOTALS]->[$OP_OPT_RTLEN]->[$i] = 0;
                $PKT->[$TOTALS]->[$OP_DIF_RTLEN]->[$i] = 0;
        }
}


# ======================================================================
# Output Routines
# ======================================================================
sub print_totals {

	my $A = shift(@_);
	my $B = shift(@_);
	my $C = shift(@_);

	printf("\t%s %s Transmitted\n", $B, $C);
	printf("\t\tPackets:        %d\n", $A->[$OP_TX]->[$PCNT]);
	printf("\t\tBytes:          %d\n", $A->[$OP_TX]->[$BCNT]);

	printf("\t%s %s Received\n", $B, $C);
	printf("\t\tPackets:        %d\n", $A->[$OP_RX]->[$PCNT]);
	printf("\t\tBytes:          %d\n", $A->[$OP_RX]->[$BCNT]);

        printf("\t%s %s Forwards\n", $B, $C);
        printf("\t\tPackets:        %d\n", $A->[$OP_FW]->[$PCNT]);
        printf("\t\tBytes:          %d\n", $A->[$OP_FW]->[$BCNT]);

        printf("\t%s %s Drops\n", $B, $C);
        printf("\t\tPackets:        %d\n", $A->[$OP_DR]->[$PCNT]);
        printf("\t\tBytes:          %d\n", $A->[$OP_DR]->[$BCNT]);

        if($SCRIPT_TYPE eq "RTR" || $SCRIPT_TYPE eq "TRP") {
                printf("\t\tNo Route:       %d\n",
                       $A->[$OP_DR]->[$DR_RTR_NRT]);
                printf("\t\tTTL Expired:    %d\n",
                       $A->[$OP_DR]->[$DR_RTR_TTL]);
                printf("\t\tRTR Queue Full: %d\n",
                       $A->[$OP_DR]->[$DR_RTR_IFQ]);
                printf("\t\tTimeout:        %d\n",
                       $A->[$OP_DR]->[$DR_RTR_TOUT]);
                printf("\t\tRouting Loop:   %d\n",
                       $A->[$OP_DR]->[$DR_RTR_LOOP]);
                printf("\t\tIFQ Full:       %d\n",
                       $A->[$OP_DR]->[$DR_IFQ_FULL]);
                printf("\t\tARP Full:       %d\n",
                       $A->[$OP_DR]->[$DR_IFQ_ARP]);  
                printf("\t\tMAC Callback:   %d\n",
                       $A->[$OP_DR]->[$DR_RTR_MAC_CALLBACK]);
		printf("\t\tSIM End:        %d\n",
		       $A->[$OP_DR]->[$DR_SIM_END]);
        }

        elsif($SCRIPT_TYPE eq "MAC") {
                printf("\t\tCollision:     %d\n",
                       $A->[$OP_DR]->[$DR_MAC_COL]);
                printf("\t\tDuplicate:     %d\n",
                       $A->[$OP_DR]->[$DR_MAC_DUP]);
                printf("\t\tCRC Invalid:   %d\n",
                       $A->[$OP_DR]->[$DR_MAC_ERR]);
                printf("\t\tMax Retries:   %d\n",
                       $A->[$OP_DR]->[$DR_MAC_RET]);
                printf("\t\tInvalid State: %d\n",
                       $A->[$OP_DR]->[$DR_MAC_STA]);
                printf("\t\tMAC Busy:      %d\n",
                       $A->[$OP_DR]->[$DR_MAC_BSY]);
        }

        elsif($SCRIPT_TYPE eq "AGT") {
        }

        else {
                print stderr "Invalid SCRIPT_TYPE: '$SCRIPT_TYPE'\n";
                if ($log_error_fatal) { exit 1; }
        }
        printf("\t%s %s Overhead\n", $B, $C);
        printf("\t\tPackets:       %d\n", $A->[$OP_OVERHEAD]->[$PCNT]);
        printf("\t\tBytes:         %d\n", $A->[$OP_OVERHEAD]->[$BCNT]);
}


sub show_totals {

	my $PKT = shift(@_);

	printf("\n%s Packets ========================================\n", $PKT);

	if($PKT eq "TOTAL") {
		print_totals($PKT, $PKT, "");
	}
	else {
		print_totals($PKT->[$TOTALS], $PKT, "TOTALS");
	}

	if ($PKT eq "DSR") {
	    printf("\t send buffer drops: %d\n",$snd_buf_drop);
	    printf("\t new route requests: %d\n",$new_request);
	    printf("\t replies sent by target: %d\n",$reply_sent);
	    printf("\t replies sent from cache: %d\n",$cache_reply_sent);
	    printf("\t replies received: %d\n",$reply_received);
	    printf("\t grat replies: %d\n",$grat_reply_sent);
	    printf("\t packets salvaged: %d\n",$pkts_salvaged);
	    printf("\t packets not salvaged: %d\n",$pkts_not_salvaged);
	    printf("\t bad replies not salvaged: %d\n",
		   $bad_reply_not_salvaged);
	    printf("\t IFQ len above 25: %d\n",$ifq_above_25);
	}

        if ($PKT eq "CBRP") {
	    printf("\t send buffer drops: %d\n",$snd_buf_drop);
	    printf("\t new route requests: %d\n",$cbrp_new_request);
	    printf("\t request broadcasted by clusterheads: %d\n",$cbrp_request_broadcast);
            printf("\t replies sent by target: %d\n",$cbrp_reply_sent);    
            printf("\t cache replies sent: %d\n",$cbrp_cache_reply_sent);    
            printf("\t replies received: %d\n", $cbrp_reply_received);
            printf("\t packets salvaged by localrepair: %d\n",$cbrp_pkts_salvaged_localrepair);
            printf("\t packets salvaged by cache: %d\n",$cbrp_pkts_salvaged_cache);
            printf("\t packets not salvaged: %d\n",$pkts_not_salvaged); 
            printf("\t route requests salvaged: %d\n", $cbrp_pkts_salvaged_request);
            printf("\t route requests dropped: %d\n",$cbrp_pkts_dropped_request);
            printf("\t route reply salvaged: %d\n", $cbrp_pkts_salvaged_reply);
            printf("\t route reply dropped(loop): %d\n",$cbrp_pkts_dropped_reply_looped);
            printf("\t route reply dropped(no-route): %d\n",$cbrp_pkts_dropped_reply_no_route);
            printf("\t routes successfully shortened: %d\n",$cbrp_pkts_success_route_shortened);
            printf("\t routes wrongly shortened: %d\n",$cbrp_pkts_wrong_route_shortened);       
            printf("\t gratuitous reply (repaired): %d\n",$cbrp_pkts_grat_reply_repaired);
            printf("\t gratuitous reply (shortened): %d\n",$cbrp_pkts_grat_reply_shortened);
            printf("\t IFQ len above 25: %d\n",$ifq_above_25);  
        }

	if(! @_) {
		return;
	}

	#
	# Individual Packet Formats
	#
	$tcnt = $PKT->[$TOTALS]->[$OP_TX]->[$PCNT];
	while(@_) {
		$P = shift(@_);

		$tcnt -= $PKT->{$P}->[$OP_TX]->[$PCNT];

		printf("\n\t%s %s Packets\n", $PKT, $P);

		print_totals($PKT->{$P}, $PKT, $P);
	}

	if($tcnt != 0) {
		print stderr "Error in sent totals.\n";
		# if ($log_error_fatal) { exit 1; }
	}
}

sub show_cbr_totals {

        show_totals(CBR);

        printf("\nDistributions:\n");    

        #
        # Optimal Route Length
        #
        my $sum = 0;
        printf("\tOptimal Path Len on sending\n");
        for($i = 1; $i <= $MAX_ROUTE_LENGTH; $i++) {
                printf("\t\t Optimal Len %2d: %d\n",
                       $i, CBR->[$TOTALS]->[$OP_OPT_RTLEN]->[$i]);
                $sum += CBR->[$TOTALS]->[$OP_OPT_RTLEN]->[$i];
        }
        printf("\t\t Optimal Len>%2d: %2d\n",
               $MAX_ROUTE_LENGTH,
               CBR->[$TOTALS]->[$OP_OPT_RTLEN]->[$MAX_ROUTE_LENGTH + 1]);
        $sum += CBR->[$TOTALS]->[$OP_OPT_RTLEN]->[$MAX_ROUTE_LENGTH + 1];
        printf("\t\t Optimal Len Sum: %2d\n", $sum);


        #
        # Actual Route Length
        #
        $sum = 0;
        printf("\tActual Path Len on receiving\n");
        for($i = 1; $i <= $MAX_ROUTE_LENGTH; $i++) {
                printf("\t\t Actual Len %2d: %d\n",
                       $i, CBR->[$TOTALS]->[$OP_ACT_RTLEN]->[$i]);
                $sum += CBR->[$TOTALS]->[$OP_ACT_RTLEN]->[$i];
        }
        printf("\t\t Actual Len>%2d: %d\n",
               $MAX_ROUTE_LENGTH, 
               CBR->[$TOTALS]->[$OP_ACT_RTLEN]->[$MAX_ROUTE_LENGTH + 1]);
        $sum += CBR->[$TOTALS]->[$OP_ACT_RTLEN]->[$MAX_ROUTE_LENGTH + 1];
        printf("\t\t Actual Len Sum:  %d\n", $sum);

        #
        # Difference between Actual and Optimal
        #
        $sum = 0;
        printf("\tActual - Optimal Path Len on receiving\n");
        for($i = 0; $i <= $MAX_ROUTE_LENGTH; $i++) {
                printf("\t\t Actual - Optimal Len %2d: %d\n",
                       $i, CBR->[$TOTALS]->[$OP_DIF_RTLEN]->[$i]);
                $sum += CBR->[$TOTALS]->[$OP_DIF_RTLEN]->[$i];
        }
        printf("\t\t Actual - Optimal Len>%2d: %d\n",
               $MAX_ROUTE_LENGTH,
               CBR->[$TOTALS]->[$OP_DIF_RTLEN]->[$MAX_ROUTE_LENGTH + 1]);
        $sum += CBR->[$TOTALS]->[$OP_DIF_RTLEN]->[$MAX_ROUTE_LENGTH + 1];
        printf("\t\t Actual - Optimal Len Sum: %d\n", $sum);

        #
        # Per Node Information...
        #
        if($SCRIPT_TYPE eq "MAC" || $SCRIPT_TYPE eq "RTR") {
                printf("\n");
                for($n = 1; $n <= $MAX_NODES; $n++) {
                        print_totals(CBR->[$n], CBR, "TOTALS $n");
                        printf("\n");
                }
        }
}


# ======================================================================