totals.pl.sav

在Linux下做的QuadTree的程序

					#
					for($i = 1; $i <= $MAX_ROUTE_LENGTH; $i += 1) {
						printf("%2d %2d --- %s  Route Length: %d, Packet Count: %d\n",
							$src, $dst, $pkt, $i, TCP->[$src]->[$dst]->{$pkt}->[$ACT_RTLEN]->[$i]);
					}
					#
					# Larger than MAX ROUTE LENGTHS
					#
					printf("%2d %2d --- %s  Route Length: %d, Packet Count: %d\n",
						$src, $dst, $pkt,
						TCP->[$src]->[$dst]->{$pkt}->[$ACT_RTLEN]->[$MAX_ROUTE_LENGTH+1]->[$CNT_L],
						TCP->[$src]->[$dst]->{$pkt}->[$ACT_RTLEN]->[$MAX_ROUTE_LENGTH+1]->[$CNT_P]);
					#
					# Actual-Optimal Route Lengths
					#
					for($i = 0; $i < $MAX_ROUTE_LENGTH; $i += 1) {
						printf("%2d %2d --- %s  Actual-Optimal: %d, Packet Count: %d\n",
							$src, $dst, $pkt, $i, TCP->[$src]->[$dst]->{$pkt}->[$OPT_RTLEN]->[$i]);
					}
					#
					# Larger than MAX OPTIMAL ROUTE LENGTHS
					#
					printf("%2d %2d --- %s  Actual-Optimal: %d, Packet Count: %d\n",
						$src, $dst, $pkt,
						TCP->[$src]->[$dst]->{$pkt}->[$OPT_RTLEN]->[$MAX_ROUTE_LENGTH+1]->[$CNT_L],
						TCP->[$src]->[$dst]->{$pkt}->[$OPT_RTLEN]->[$MAX_ROUTE_LENGTH+1]->[$CNT_P]);

				}

				#
				#  Forwarding Packets
				#
				if(TCP->[$src]->[$dst]->{$pkt}->[$OP_TX]->[$CNT_F] > 0) {
					printf("  %2d --- forwarded %5d %s packets\n",
						$dst, TCP->[$src]->[$dst]->{$pkt}->[$OP_TX]->[$CNT_F], $pkt);
				}

				next;

				printf("\tDest: %d --- %s\n", $dst, $pkt);

				printf("\t\t\tTX: %4d %4d %6.2f KB/sec\n",
					TCP->[$src]->[$dst]->{$pkt}->[$OP_TX]->[$CNT_P],
					TCP->[$src]->[$dst]->{$pkt}->[$OP_TX]->[$CNT_S],
					TCP->[$src]->[$dst]->{$pkt}->[$OP_TX]->[$CNT_B]/ (1024 * $time));

				printf("\t\t\tRX: %4d %4d %6.2f KB/sec\n",
					TCP->[$src]->[$dst]->{$pkt}->[$OP_RX]->[$CNT_P],
					TCP->[$src]->[$dst]->{$pkt}->[$OP_RX]->[$CNT_S],
					TCP->[$src]->[$dst]->{$pkt}->[$OP_RX]->[$CNT_B]/ (1024 * $time));

				printf("\t\t\tSD: %d, RD: %d\n",
					TCP->[$src]->[$dst]->{$pkt}->[$OP_SD]->[$CNT_P],
					TCP->[$src]->[$dst]->{$pkt}->[$OP_RD]->[$CNT_P]);

			}
		}
	}
	printf("\n");
}


# ======================================================================
# TORA Packet Processing Routines
# ======================================================================
sub process_tora {
	$OP = shift(@_);		# send, receive, drop
	$RXMT = shift(@_);		# retransmission (YES/NO)
	$SIZE = shift(@_);		# packet size
	$LINE = shift(@_);		# line from log file

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

		TORA->{$pkt}->[$OP]->[$CNT_P] += 1;
		TORA->{$pkt}->[$OP]->[$CNT_R] += $RXMT;
		TORA->{$pkt}->[$OP]->[$CNT_B] += $SIZE;
	}
	else {
		print stderr "TORA Logging error\n$LINE\n";
		exit 1;
	}

	TORA->[$TOTALS]->[$OP]->[$CNT_P] += 1;
	TORA->[$TOTALS]->[$OP]->[$CNT_R] += $RXMT;
	TORA->[$TOTALS]->[$OP]->[$CNT_B] += $SIZE;
}


# ======================================================================
# DSR Packet Processing Routines
# ======================================================================
sub process_dsr {
	$OP = shift(@_);		# send, receive, drop
	$RXMT = shift(@_);		# retransmission (YES/NO)
	$SIZE = shift(@_);		# packet size
	$LINE = shift(@_);		# line from log file

	if($LINE =~ / (\d+) (\w+) (\d+) -- (\d+)->(\d+) (\d+) \[(\d+)\] \[(\d+) (\d+) (\d+)\] \[(\d+) (\d+) (\d+)->(\d+)\]/o) {
		$node = $1;
		# $pkttype = $2;
		# $pktsize = $3;
		$src_ipaddr = $4;
		$dst_ipaddr = $5;
		$pkt_len = $6;
		$pkt_request = $7;
		$pkt_reply = $8;
		$pkt_reply_len = $9;
		$pkt_reply_dst = $10;
		$pkt_error = $11;
		$pkr_error_cnt = $12;
		$pkt_error_src = $13;
		$pkt_error_dst = $14;

		if($pkt_request && ($node == $src_ipaddr || $node == $dst_ipaddr)) {
			$pkt = "REQUEST";

			DSR->{$pkt}->[$OP]->[$CNT_P] += 1;
			DSR->{$pkt}->[$OP]->[$CNT_R] += $RXMT;
			DSR->{$pkt}->[$OP]->[$CNT_B] += $SIZE;
		}

		if($pkt_reply && ($node == $src_ipaddr || $node == $dst_ipaddr)) {
			$pkt = "REPLY";

			DSR->{$pkt}->[$OP]->[$CNT_P] += 1;
			DSR->{$pkt}->[$OP]->[$CNT_R] += $RXMT;
			DSR->{$pkt}->[$OP]->[$CNT_B] += $SIZE;
		}

		if($pkt_error && ($node == $src_ipaddr || $node == $dst_ipaddr)) {
			$pkt = "ERROR";

			DSR->{$pkt}->[$OP]->[$CNT_P] += 1;
			DSR->{$pkt}->[$OP]->[$CNT_R] += $RXMT;
			DSR->{$pkt}->[$OP]->[$CNT_B] += $SIZE;
		}

	}
	else {
		print stderr "DSR Logging error\n$LINE\n";
		exit 1;
	}
	DSR->[$TOTALS]->[$OP]->[$CNT_P] += 1;
	DSR->[$TOTALS]->[$OP]->[$CNT_R] += $RXMT;
	DSR->[$TOTALS]->[$OP]->[$CNT_B] += $SIZE;
}

# ======================================================================
# CBR Packet Processing Routines
# ======================================================================
#s 5.73300 [20 42 2b 29 800] 41 cbr 1060 ------- 0 [41:2 43:0] 20 22 [0 0x8 0]
sub process_cbr {
	$OP = shift(@_);		# send, receive, drop
	$RXMT = shift(@_);		# retransmission (YES/NO)
	$SIZE = shift(@_);		# packet size
	$LINE = shift(@_);		# line from log file

	if($LINE =~ /^.*\] (\d+) cbr .*\[(\d+):(\d+) (\d+):(\d+) \d+\] \[\d+\] (\d+) (\d+)/o) {
	    $node = $1;
	    $src_ipaddr = $2;
	    $src_ipport = $3;
	    $dst_ipaddr = $4;
	    $dst_ipport = $5;
	    $rt_len = $6;
	    $opt_rt_len = $7;		# optimal length
#		$sr_bytes = hex($7);		# bytes in sr hdr if using DSR

	    $kind = "UNIQUE";
	    if($OP == $OP_TX && $node == $src_ipaddr && $rl_len == 0) {
		$dsr_hdr_bytes += $sr_bytes;
		CBR->{$kind}->[$OP]->[$CNT_P] += 1;
		CBR->{$kind}->[$OP]->[$CNT_R] += $RXMT;
		CBR->{$kind}->[$OP]->[$CNT_B] += $SIZE;

		if ($opt_rt_len > $MAX_ROUTE_LENGTH) {
		    CBR->[$TOTALS]->[$GOD_RTLEN]->[$MAX_ROUTE_LENGTH + 1]->[$CNT_P] += 1;
		} else {
		    CBR->[$TOTALS]->[$GOD_RTLEN]->[$opt_rt_len] += 1;
		}
	    } elsif($OP == $OP_RX && $node == $dst_ipaddr) {
		CBR->{$kind}->[$OP]->[$CNT_P] += 1;
		CBR->{$kind}->[$OP]->[$CNT_R] += $RXMT;
		CBR->{$kind}->[$OP]->[$CNT_B] += $SIZE;
		
		if($rt_len <= 0 ) {
		    print stderr "$LINE";
		    print stderr "Actual RT Length $rt_len\n";
		    exit 1;
		}
		
		$len = $rt_len - $opt_rt_len;
		if($len < 0) {
		    print stderr "$LINE";
		    print stderr "Actual RT Length < Optimal.\n";
		    $len = 0;
		} elsif($len > $MAX_ROUTE_LENGTH) {
		    print "$LINE";
		    print "Actual RT Length > Optimal + $MAX_ROUTE_LENGTH.\n";
		    CBR->[$TOTALS]->[$OPT_RTLEN]->[$MAX_ROUTE_LENGTH + 1]->[$CNT_P] += 1;
		    CBR->[$TOTALS]->[$OPT_RTLEN]->[$MAX_ROUTE_LENGTH + 1]->[$CNT_L] += $len;
		}
		else {
		    CBR->[$TOTALS]->[$OPT_RTLEN]->[$len] += 1;
		}
		
		if($rtlen > $MAX_ROUTE_LENGTH) {
		    CBR->[$TOTALS]->[$ACT_RTLEN]->[$MAX_ROUTE_LENGTH + 1]->[$CNT_P] += 1;
		    CBR->[$TOTALS]->[$ACT_RTLEN]->[$MAX_ROUTE_LENGTH + 1]->[$CNT_L] += $len;
		}
		else {
		    CBR->[$TOTALS]->[$ACT_RTLEN]->[$rt_len] += 1;
		}
	    }
	} else {
	    print stderr "CBR Logging error\n$LINE\n";
	    exit 1;
	}
	
	CBR->[$TOTALS]->[$OP]->[$CNT_P] += 1;
	CBR->[$TOTALS]->[$OP]->[$CNT_R] += $RXMT;
	CBR->[$TOTALS]->[$OP]->[$CNT_B] += $SIZE;
}

# ======================================================================
# MAC Packet Processing Routines
# ======================================================================
sub process_msg {
        $OP = shift(@_);                # send, receive, drop
        $RXMT = shift(@_);              # retransmission (YES/NO)
        $SIZE = shift(@_);              # packet size
        $LINE = shift(@_);              # line from log file

        MSG->[$TOTALS]->[$OP]->[$CNT_P] += 1;
        MSG->[$TOTALS]->[$OP]->[$CNT_R] += $RXMT;
        MSG->[$TOTALS]->[$OP]->[$CNT_B] += $SIZE;
}

# ======================================================================
# MAC Packet Processing Routines
# ======================================================================
sub process_mac {
	$OP = shift(@_);		# send, receive, drop
	$RXMT = shift(@_);		# retransmission (YES/NO)
	$SIZE = shift(@_);		# packet size
	$LINE = shift(@_);		# line from log file

	if($LINE =~ /\[(\w+) (\w+) (\w+) (\w+) (\w+)\]/o) {
		$t = hex($1) & 255;

		if($t == $MACTYPE_RTS) {
			$pkt = "RTS";
		}
		elsif($t == $MACTYPE_CTS) {
			$pkt = "CTS";
		}
		elsif($t == $MACTYPE_ACK) {
			$pkt = "ACK";
		}
		else {
			print stderr "Invalid MAC packet.\n";
			exit 1;
		}

		MAC->{$pkt}->[$OP]->[$CNT_P] += 1;
		MAC->{$pkt}->[$OP]->[$CNT_R] += $RXMT;
		MAC->{$pkt}->[$OP]->[$CNT_B] += $SIZE;
	}
	else {
		print stderr "MAC Logging error\n$LINE\n";
		exit 1;
	}

	MAC->[$TOTALS]->[$OP]->[$CNT_P] += 1;
	MAC->[$TOTALS]->[$OP]->[$CNT_R] += $RXMT;
	MAC->[$TOTALS]->[$OP]->[$CNT_B] += $SIZE;
}


# ======================================================================
# Main Procedure
# ======================================================================
if($#ARGV != 1) {
	print stderr "\nusage: $0 <input file> <num nodes>\n\n";
	exit 1;
}

if(! open $infile, $ARGV[0]) {
	print stderr "Could not open $ARGV[0]\n";
	exit 1;
}

$MAX_NODES = $ARGV[1];
$TOTALS = $MAX_NODES + 1;

#
# Initialize Data Structures
#
init_type(MAC, @MACTYPE);
init_type(CBR, @CBRTYPE);
init_type(ARP, @ARPTYPE);
init_type(DSR, @DSRTYPE);
init_type(TORA, @TORATYPE);
init_type(TCP, @TCPTYPE); init_tcp();

while(<$infile>) {

	$line += 1;

	if(/^[rsfD] (\d+).\d+ \D+ \D+ \[(\w+) \w+ (\w+) (\w+) (\w+)\] (\d+) (\D+) (\d+)/o) {
		$time = $1;
		$mac_type = hex($2);
		$mac_dst = hex($3);
		$mac_src = hex($4);
		$ether_type = hex($5);
		$node = $6;
		$pkttype = $7;
		$pktsize = $8;

		$retransmit = 0;

		if($mac_type > 255) {
			$retransmit = 1;
			$mac_type &= 255;
		}

		if(/^s / || /^f /) {
			$opcode = $OP_TX;
		}
		elsif(/^r /) {
			$opcode = $OP_RX;
		}
		elsif(/^D / || /^d /) {
			if($mac_src == $node) {
				$opcode = $OP_SD;
			}
			else {
				$opcode = $OP_RD;
			}
		}
		else {
			print stderr "Invalid OPERATION\n$_\n";
			exit 1;
		}

		if($mac_type == $MACTYPE_RTS ||
		   $mac_type == $MACTYPE_CTS ||
		   $mac_type == $MACTYPE_ACK) {
			process_mac($opcode, $retransmit, $pktsize, $_);
		}
		elsif($mac_type == $MACTYPE_DATA || $mac_type == 0) {
			if($pkttype eq "ARP") {
#				process_arp($opcode, $retransmit, $pktsize, $_);
			}
			elsif($pkttype eq "tcp" ||
			      $pkttype eq "ack") {
				process_tcp($opcode, $retransmit, $pktsize, $_);
			}
			elsif($pkttype eq "TORA") {
				process_tora($opcode, $retransmit, $pktsize, $_);
			}
			elsif($pkttype eq "cbr") {
				process_cbr($opcode, $retransmit, $pktsize, $_);
			}
			elsif($pkttype eq "DSR") {
#				process_dsr($opcode, $retransmit, $pktsize, $_);
			}
			elsif($pkttype eq "message") {
#			    process_msg($opcode, $retransmit, $pktsize, $_);
			}	
			else {
			    print stderr "Invalid packet type $pkttype\n";
			    exit 1;
			}
		}
		else {
			print stderr "Invalid packet type $pkttype\n";
			exit 1;
		}
	}
	#
	# Mobility Logging
	#
	elsif(/^M /o) {
	}
	#
	# TORA Logging
	#
	elsif(/^T /o) {
	}
	#
	# DSR Logging
	#
	elsif(/^S/o) {
	}
	#
	# DSDV Logging
	#
	elsif(/^V/o) {
	}
	#
	# GOD Logging
	#
	elsif(/^G/o) {
	}
	else {
		print stderr "Error, $line: '$_'\n";
		exit 1;
	}
}

$time += 1;		# accounts for fractional part


#
# Compute Totals for the Simulation
#
foreach $PKT (MAC, ARP, DSR, TORA, TCP, CBR) {
	foreach $OP ($OP_TX, $OP_RX, $OP_SD, $OP_RD) {
		TOTAL->[$OP]->[$CNT_P] += $PKT->[$TOTALS]->[$OP]->[$CNT_P];
		TOTAL->[$OP]->[$CNT_B] += $PKT->[$TOTALS]->[$OP]->[$CNT_B];
		TOTAL->[$OP]->[$CNT_R] += $PKT->[$TOTALS]->[$OP]->[$CNT_R];
	}
}

show_totals(MAC, @MACTYPE);
#show_totals(ARP, @ARPTYPE);
#show_totals(DSR, @DSRTYPE);
#show_totals(MSG, @MSGTYPE);
show_totals(TORA, @TORATYPE);
show_cbr_totals();
show_tcp_totals();

printf("\nSimulation Time: %d\n", $time);
show_totals(TOTAL);