Per sostituzioni così semplici, a mio avviso l'uso di str_replace() è SEMPRE conveniente. Questo il mio listato adattato (occhio che ho dovuto doppioslashare l'espressione regolare perché mi mangiava un backslash):

Codice PHP:
<?php
$template = '
<html><head><title>template</title>
</head>
<body>
Sicuramente i  

ameranno la  
</body>
</html>';
$template_eval = '$_tmp = "
<html><head><title>template</title>
</head>
<body>
Sicuramente i $name 

ameranno la $pippo 
</body>
</html>";';

function parse_eval($template) {
    $name = 'fagiani';
    $pippo = 'pillola';

    eval($template);
    echo $_tmp;
}

function parse_preg($template) {
    $name = 'fagiani';
    $pippo = 'pillola';

    echo preg_replace('/()/e', '$$2', $template);
}

function parse_replace($template) {
    $name = 'fagiani';
    $pippo = 'pillola';

    foreach(get_defined_vars() as $_name => $_value) {
        $template = str_replace('', $_value, $template);
    }

    echo $template;
}

$start = microtime(true);
//echo parse_eval($template_eval);
for ($n=0; $n<100000; ++$n) {
    ob_start();
    parse_eval($template_eval);
    ob_end_clean();
}
$t = microtime(true) - $start;
echo "parse_eval: $n cicli in $t secondi\n";

$start = microtime(true);
//echo parse_preg($template);
for ($n=0; $n<100000; ++$n) {
    ob_start();
    parse_preg($template);
    ob_end_clean();
}
$t = microtime(true) - $start;
echo "parse_preg: $n cicli in $t secondi\n";

$start = microtime(true);
//echo parse_replace($template);
for ($n=0; $n<100000; ++$n) {
    ob_start();
    parse_replace($template);
    ob_end_clean();
}
$t = microtime(true) - $start;
echo "parse_replace: $n cicli in $t secondi\n";
?>
Ho eseguito una serie di test usando eval(), preg_replace() e str_replace(): in realtà preg_replace() risulta sensibilmente più lenta in tutti i test (a meno che qualcosa mi sfugga). Comunque, questi i risultati (PHP 5.2.4 CLI):

codice:
parse_eval: 100000 cicli in 1.2966370582581 secondi
parse_preg: 100000 cicli in 1.8667900562286 secondi
parse_replace: 100000 cicli in 1.0892291069031 secondi
str_replace() è la più rapida.

Di più, ho modificato i templates per far stampare entrambi i tag tre volte e vedere come si comporta con ripetizione di tags:
codice:
parse_eval: 100000 cicli in 1.8374869823456 secondi
parse_preg: 100000 cicli in 3.9160349369049 secondi
parse_replace: 100000 cicli in 1.3093018531799 secondi
Si può notare che il rendimento di parse_preg() è crollato.

Ho aggiunto più variabili da sostituire (6):
codice:
parse_eval: 100000 cicli in 1.9696319103241 secondi
parse_preg: 100000 cicli in 4.4429740905762 secondi
parse_replace: 100000 cicli in 2.5497419834137 secondi
Il rendimento di parse_replace() è crollato.

Ho aggiunto ai templates 400 bytes di testo statico da NON sostituire:
codice:
parse_eval: 100000 cicli in 3.8357100486755 secondi
parse_preg: 100000 cicli in 4.7148230075836 secondi
parse_replace: 100000 cicli in 2.9533319473267 secondi
Il rendimento di parse_eval() è crollato.

Conclusione? Ognuno si scelga il metodo più idoneo alle sue necessità. L'unica cosa certa è che, almeno sul mio PC e con il PHP 5.2.4 (e nella forma adottata), il parsing con preg_replace() ha avuto i risultati peggiori in ogni prova.