totals.pl

在Linux下做的QuadTree的程序

                for($n = 1; $n <= $MAX_NODES; $n++) {
                        print_totals(CBR->[$n], CBR, "TOTALS $n");
                        printf("\n");
                }
        }
}


# ======================================================================
# ARP Packet Processing Routines
# ======================================================================
sub log_drop {
        my $A = shift(@_);
        my $LOGTYPE = shift(@_);
        my $REASON = shift(@_);

        if($LOGTYPE eq "MAC") {
                if($REASON eq "COL") {
                        $A->[$DR_MAC_COL] += 1;
                }
                elsif($REASON eq "DUP") {
                        $A->[$DR_MAC_DUP] += 1;
                }
                elsif($REASON eq "ERR") {
                        $A->[$DR_MAC_ERR] += 1;
                }
                elsif($REASON eq "RET") {
                        $A->[$DR_MAC_RET] += 1;
                }
                elsif($REASON eq "STA") {
                        $A->[$DR_MAC_STA] += 1;
                }
                elsif($REASON eq "BSY") {
                        $A->[$DR_MAC_BSY] += 1;
                }
                else {
                        print stderr "Invalid Drop Reason '$REASON'\n";
                        if ($log_error_fatal) { exit 1; }
                }
        }
        elsif($LOGTYPE eq "IFQ" && $SCRIPT_TYPE eq "RTR") {
	        if($REASON eq "IFQ") {
                        $A->[$DR_IFQ_FULL] += 1;
                }
                elsif($REASON eq "ARP") {
                        $A->[$DR_IFQ_ARP] += 1;
                }
		elsif($REASON eq "END") {
			$A->[$DR_SIM_END] += 1;
		}
                else {
                        print stderr "Invalid IFQ Drop Reason '$REASON'\n";
                        if ($log_error_fatal) { exit 1; }
                }
        }
        elsif($LOGTYPE eq "RTR" || $LOGTYPE eq "TRP") {
                if($REASON eq "NRTE") {
                        $A->[$DR_RTR_NRT] += 1;
                }
                elsif($REASON eq "TTL") {
                        $A->[$DR_RTR_TTL] += 1;
                }
                elsif($REASON eq "IFQ") {
                        $A->[$DR_RTR_IFQ] += 1;
                }
                elsif($REASON eq "TOUT") {
                        $A->[$DR_RTR_TOUT] += 1;
                }
                elsif($REASON eq "LOOP") {
                        $A->[$DR_RTR_LOOP] += 1;
                }
                elsif($REASON eq "CBK") {
                        $A->[$DR_RTR_MAC_CALLBACK] += 1;
                }
		elsif($REASON eq "END") {
			$A->[$DR_SIM_END] += 1;
		}
                else {
                        print stderr "Invalid RTR Drop Reason '$REASON'\n";
                        if ($log_error_fatal) { exit 1; }
                }
        }
        elsif($LOGTYPE eq "AGT") {
        }
        else {
                print stderr "Invalid Script Type\n";
                if ($log_error_fatal) { exit 1; }
        }
}


sub process_arp {
        my $hdr = shift(@_);
        my $LINE = shift(@_);              # line from log file

        my $OP = $hdr->{opcode};
        my $LOGTYPE = $hdr->{logtype};
        my $REASON = $hdr->{logreason};
        my $SIZE = $hdr->{pktsize};

	if($LINE =~ / ------- \[(\w+) (\d+)\/(\d+) (\d+)\/(\d+)\]/o) {
		$pkt = $1;

		if( $pkt != "REQUEST" && $pkt != "REPLY" ) {
			print stderr "Invalid ARP packet.\n";
			if ($log_error_fatal) { exit 1; }
		}
		ARP->{$pkt}->[$OP]->[$PCNT] += 1;
		ARP->{$pkt}->[$OP]->[$BCNT] += $SIZE;

                if($OP == $OP_DR) {
                        log_drop(ARP->{$pkt}->[$OP], $LOGTYPE, $REASON);
                }
	}
	else {
		print stderr "ARP Logging error\n$LINE\n";
		if ($log_error_fatal) { exit 1; }
	}

	ARP->[$TOTALS]->[$OP]->[$PCNT] += 1;
	ARP->[$TOTALS]->[$OP]->[$BCNT] += $SIZE;
}

# ======================================================================
# TORA Packet Processing Routines
# ======================================================================
sub process_tora {
        my $hdr = shift(@_);
        my $LINE = shift(@_);              # line from log file

        my $OP = $hdr->{opcode};
        my $LOGTYPE = $hdr->{logtype};
        my $REASON = $hdr->{logreason};
        my $SIZE = $hdr->{pktsize};

	if($LINE =~ / ------- \[\d+:\d+ \S+:\d+ \d+ \d+\].*\((\D+)\)/o) {
		$pkt = $1;

		TORA->{$pkt}->[$OP]->[$PCNT] += 1;
		TORA->{$pkt}->[$OP]->[$BCNT] += $SIZE;

                if($OP == $OP_DR) {
                        log_drop(TORA->{$pkt}->[$OP], $LOGTYPE, $REASON);
                }
	}
	else {
		print stderr "TORA Logging error\n$LINE\n";
		if ($log_error_fatal) { exit 1; }
	}

	TORA->[$TOTALS]->[$OP]->[$PCNT] += 1;
	TORA->[$TOTALS]->[$OP]->[$BCNT] += $SIZE;
}

# ======================================================================
# IMEP Packet Processing Routines
# ======================================================================
sub process_imep {
        my $hdr = shift(@_);
        my $LINE = shift(@_);              # line from log file

        my $OP = $hdr->{opcode};
        my $LOGTYPE = $hdr->{logtype};
        my $REASON = $hdr->{logreason};
        my $SIZE = $hdr->{pktsize};
#s 1.11 _11_ RTR  --- 24 IMEP 23 [0 0 0 0 0] ------- [11:255 -1:255 1 0] [- - - 0x0003] 

	if($LINE =~ / ------- \[\d+:\d+ \S+:\d+ \d+ \d+\] \[(.) (.) (.)/o) {
	    $ack = $1;
	    $hello = $2;
	    $object = $3;
	    
	    $pkt = "BEACON";

	    if ($ack ne '-') {
		$pkt = "ACK";
		IMEP->{$pkt}->[$OP]->[$PCNT] += 1;
	    }
	    if ($hello ne '-') {
		$pkt = "HELLO";
		IMEP->{$pkt}->[$OP]->[$PCNT] += 1;
	    }
	    if ($object ne '-') {
		$pkt = "OBJECT";
		IMEP->{$pkt}->[$OP]->[$PCNT] += 1;
	    }
	    if ($pkt eq "BEACON") {
		IMEP->{$pkt}->[$OP]->[$PCNT] += 1;
	    }

	    if($OP == $OP_DR) {
		log_drop(IMEP->{$pkt}->[$OP], $LOGTYPE, $REASON);
	    }
	}
	else {
		print stderr "IMEP Logging error\n$LINE\n";
		if ($log_error_fatal) { exit 1; }
	}

	IMEP->[$TOTALS]->[$OP]->[$PCNT] += 1;
	IMEP->[$TOTALS]->[$OP]->[$BCNT] += $SIZE;
}

# ======================================================================
# AODV Packet Processing Routines
# ======================================================================
sub process_aodv {
        my $hdr = shift(@_);
        my $LINE = shift(@_);              # line from log file

        my $OP = $hdr->{opcode};
        my $LOGTYPE = $hdr->{logtype};
        my $REASON = $hdr->{logreason};
        my $SIZE = $hdr->{pktsize};

	if($LINE =~ / ------- \[\d+:\d+ \S+:\d+ \d+ \d+\].*\((\D+)\)/o) {
		$pkt = $1;

		AODV->{$pkt}->[$OP]->[$PCNT] += 1;
		AODV->{$pkt}->[$OP]->[$BCNT] += $SIZE;

                if($OP == $OP_DR) {
                        log_drop(AODV->{$pkt}->[$OP], $LOGTYPE, $REASON);
                }
	}
	else {
		print stderr "AODV Logging error\n$LINE\n";
		if ($log_error_fatal) { exit 1; }
	}

	AODV->[$TOTALS]->[$OP]->[$PCNT] += 1;
	AODV->[$TOTALS]->[$OP]->[$BCNT] += $SIZE;
}

# ======================================================================
# DSR Packet Processing Routines
# ======================================================================
sub process_dsr {
        my $hdr = shift(@_);
        my $LINE = shift(@_);              # line from log file

        my $OP = $hdr->{opcode};
        my $LOGTYPE = $hdr->{logtype};
        my $REASON = $hdr->{logreason};
        my $SIZE = $hdr->{pktsize};

	if($LINE =~ / ------- \[(\d+):\d+ \d+:\d+ \d+ \d+\] \d+ \[(\d+) \d+ \d+\] \[(\d+) (\d+) \d+ \d+->(\d+)\] \[(\d+) \d+ \d+ \d+->\d+\]/o) {
		my $node = $hdr->{node};
		my $src_ipaddr = $1;
#		my $src_port = $2;
#		my $dst_ipaddr = $3;
#		my $dst_port = $4;
		my $pkt_req = $2;
#		my $pkt_req_seqno = $6;
		my $pkt_rep = $3;
		my $pkt_rep_seqno = $4;
#		my $pkt_rep_len = $9;
#		my $pkt_rep_src = $10;
		my $pkt_rep_dst = $5;
		my $pkt_err = $6;
#		my $pkt_err_cnt = $13;
#		my $pkt_err_tell = $14;
#		my $pkt_error_src = $15;
#		my $pkt_error_dst = $16;

		if($pkt_req) {
			$pkt = "REQUEST";
		}
		elsif($pkt_rep) {
			if($pkt_rep_seqno == 0) {
				$pkt = "GRAT REPLY";
			}
			elsif($pkt_rep_dst != $src_ipaddr) {
				$pkt = "CACHED REPLY";
			}
			else {
				$pkt = "REPLY";
			}
		}
		elsif($pkt_err) {
			$pkt = "ERROR";
		}
		else {
			if($OP != $OP_DR) {
				print stderr "Invalid DSR Packet Type\n";
				print stderr "$_";
				if ($log_error_fatal) { exit 1; }
			}
		}

                DSR->{$pkt}->[$OP]->[$PCNT] += 1;
                DSR->{$pkt}->[$OP]->[$BCNT] += $SIZE;

                if($OP == $OP_DR) {
                        log_drop(DSR->{$pkt}->[$OP], $LOGTYPE, $REASON);
                }
	}
	else {
		print stderr "DSR Logging error\n$LINE\n";
		if ($log_error_fatal) { exit 1; }
	}

	DSR->[$TOTALS]->[$OP]->[$PCNT] += 1;
	DSR->[$TOTALS]->[$OP]->[$BCNT] += $SIZE;
}

# ======================================================================
# CBR Packet Processing Routines
# ======================================================================
sub process_cbr {
        my $hdr = shift(@_);
        my $LINE = shift(@_);              # line from log file

        my $OP = $hdr->{opcode};
        my $LOGTYPE = $hdr->{logtype};
        my $REASON = $hdr->{logreason};
        my $SIZE = $hdr->{pktsize};

	if($LINE =~ / ------- \[(\d+):(\d+) (\d+):(\d+) \d+ \d+\] \[\d+\] (\d+) (\d+)/o) {
                my $node = $hdr->{node};
                my $src_ipaddr = $1;
                my $src_ipport = $2;
                my $dst_ipaddr = $3;
                my $dst_ipport = $4;
                my $act_rt_len = $5;       # actual length
                my $opt_rt_len = $6;       # optimal length

                #
                # Count per-packet DSR Overhead bytes.
                # This is a temporary "hack" that needs to be fixed after
                # CMUTrace is modified - Josh, 98APR11
                #
                # After this gets changed:note that if you piggyback a 
                # data packet on a route request and broadcast the
                # packet, the source route bytes will be free as the
                # packet propagates out.
                #
                if($SCRIPT_TYPE eq "AGT") {
                        if($OP == $OP_RX && $node == $dst_ipaddr) {
                                CBR->[$TOTALS]->[$OP_OVERHEAD]->[$PCNT] += 1;
                                CBR->[$TOTALS]->[$OP_OVERHEAD]->[$BCNT] +=
                                  ((4 * $act_rt_len + 4) * $act_rt_len);

                                CBR->[$node]->[$OP_OVERHEAD]->[$PCNT] += 1;
                                CBR->[$node]->[$OP_OVERHEAD]->[$BCNT] +=
                                  ((4 * $act_rt_len + 4) * $act_rt_len);
                        }
                }

                ############################################################

                if($OP == $OP_DR) {
                        log_drop(CBR->[$TOTALS]->[$OP], $LOGTYPE, $REASON);
                        log_drop(CBR->[$node]->[$OP], $LOGTYPE, $REASON);
                }

                CBR->[$TOTALS]->[$OP]->[$PCNT] += 1;
                CBR->[$TOTALS]->[$OP]->[$BCNT] += $SIZE;

                #
                # Per node information...
                #
                CBR->[$node]->[$OP]->[$PCNT] += 1;
                CBR->[$node]->[$OP]->[$BCNT] += $SIZE;

                #
                # The GOD information is only meaningful in a MAC script.
                #
                if($SCRIPT_TYPE ne "AGT") {
                        return;
                }

                #
                # The distribution of OPTIMAL route lengths is collected at the sender.