eval - efficiency

hi
please excuse this rather lengthy mail ...

im a bit curious about the eval function in perl.
consider the ready-to-run script below containing 3 different
subroutines which in fact are doing the same, but with different
efficiency. i have included a switch to easily try them all.
the subroutines jobs are to look thru some content for a certain pattern
and when found replace that pattern with a value which it look up inside
a txt.file, called "dbm.txt". this txt file im testing on looks
currently exactly like this:

<tag id=1>:basic=3.00:private=13.00
<tag id=2>:basic=4.00:private=23.00
<tag id=3>:basic=5.00:private=33.00



version1 is pretty much straight forward looping.
version2 is how i thought it should be done with the eval function, as i understand
the pattern(s) then get compiled only once.
version3 is a direct version (in fact it is the printed output of the
eval in version2).

version 3 is slightly faster than version 1, which is considerably
faster than version2.

my only question is, how come the eval version is slower than
version1 (and can i make it faster)?

thanks
allan


#!perl -w

use strict;

my $content  = "
this is various content containg tags like these:
<tag id=1> (probably more content)
<tag id=2> (probably more content)
";

my $cust = "private";
my ($version1Response, $version2Response, $directResponse);
my $switch = 1;

my $start = (times)[0];

for (my $i=0;$i<=300;$i++) {
	if ($switch == 1) {
		$version1Response = normalVersion($content, $cust);
		print $version1Response;
	} elsif ($switch == 2) {	
		$version2Response = evalVersion($content, $cust);
		print $version2Response;
	} else {
		$directResponse = directVersion($content, $cust);
		print $directResponse;
	}
	
}

my $finish = (times)[0];
my $result = $finish - $start;
print "\nthis took $result";


############version 1############

sub normalVersion {
	(my $output, my $customer) = @_;
	open (FILE, "dbm.txt"); 
	while (<FILE>) {
		chomp;
		while (/(<tag[^>]+id=\d+>).+$customer=([^:]+)/g) {
			my $tag = $1;
			my $val = $2;
			$output =~ s/$tag/$val/g
		}
	}
	close(FILE);
	return  $output; 
}

############version 2############

sub evalVersion {
	(my $output, my $customer) = @_;
	my $max = 2; #this will be known
	my ($tag, $val);
	my $code = "open (FILE, \"dbm.txt\");\n";
	$code .= 'while (<FILE>) {';
	$code .= "\nchomp;";
	for (my $j=1;$j<=$max;$j++) {
			$code .= "\n\twhile (/(<tag[^>]+id=$j>).+$customer=([^:]+)/g) {\n";
#fill it with constants
			$code .= "\t\t\$tag = \$1;\n";
			$code .= "\t\t\$val = \$2;\n";
			$code .= "\t\t\$output =~ s/\$tag/\$val/go\n"; #not sure of /o benefit
			$code .= "\t}\n";
	}
	$code .= "}\n";	
	$code .= "close (FILE);\n";
	$code .= "return  \$output;";
	eval $code;
}

##########direct############

sub directVersion {
	(my $output, my $customer) = @_;
	open (FILE, "dbm.txt");
	while (<FILE>) {
	chomp;
		while (/(<tag[^>]+id=1>).+private=([^:]+)/g) {
			my $tag = $1;
			my $val = $2;
			$output =~ s/$tag/$val/go
		}
		while (/(<tag[^>]+id=2>).+private=([^:]+)/g) {
			my $tag = $1;
			my $val = $2;
			$output =~ s/$tag/$val/go
		}
	}
	close (FILE);
	return  $output;
}