eval arithmetic expression as a string vs calling function - performance

Question

I was going to advice some fellow Perl developers against eval-ing formulas as a string each time the formula is calculated, and instead eval - once - functions for each formula. Thus, instead of calling eval thousands of times, a function is called. I.e:
Instead of:
sub calc_formulas_naive
{
my %formulas;
$formulas{formula_a} = '$ref->{metric_a} + $ref->{metric_b} * $ref->{metric_c} - 100 * $ref->{metric_c} / 1000 + 33.33 * $ref->{metric_d}';
$formulas{formula_b} = '$ref->{metric_a} * $ref->{metric_c} - 33';
$formulas{formula_c} = '$ref->{metric_a} * $ref->{metric_c} - 33 + 0.265 * ($ref->{metric_d} / $ref->{metric_c}) - $ref->{metric_a} + $ref->{metric_e} * ($ref->{metric_d} + 1)';
my $ref = shift #_;
my $form_a_val = eval $formulas{formula_a};
my $form_b_val = eval $formulas{formula_b};
my $form_c_val = eval $formulas{formula_c};
}
Use:
my %formulas_adv;
sub prep_formulas_adv # called only once prior to parsing!
{
my $sub = 'sub { my $ref = shift #_; my $result = $ref->{metric_a} + $ref->{metric_b} * $ref->{metric_c} - 100 * $ref->{metric_c} / 1000 + 33.33 * $ref->{metric_d}; return $result; }';
$formulas_adv{formula_a} = eval $sub;
$sub = 'sub { my $ref = shift #_; my $result = $ref->{metric_a} * $ref->{metric_c} - 33; return $result; }';
$formulas_adv{formula_b} = eval $sub;
$sub = 'sub { my $ref = shift #_; my $result = $ref->{metric_a} * $ref->{metric_c} - 33 + 0.265 * ($ref->{metric_d} / $ref->{metric_c}) - $ref->{metric_a} + $ref->{metric_e} * ($ref->{metric_d} + 1); return $result; }';
$formulas_adv{formula_c} = eval $sub;
}
sub calc_formulas_advanced
{
my $ref = shift #_;
my $form_a_val = $formulas_adv{formula_a}($ref);
my $form_b_val = $formulas_adv{formula_b}($ref);
my $form_c_val = $formulas_adv{formula_c}($ref);
}
Now the question itself. I was totally sure that 2nd approach gives noticeable advantage when processing big amounts of data. I haven't had access to my old projects, but I also was quite sure I saw the 2nd approach working faster than the 1st. After all, Perl doesn't have to compile anything on-the-run in this case.
But before giving the advice, I wrote a small artificial example with 5K text files populated with rand generated metrics, ran both implementations, and... I don't observe any advantage of using unnamed functions over strings evaluation.
What's the matter? Was I hallucinating all the time, when I thought that eval is less effective than a function?