PHP5 - Quel est le coût de RTTI (obtenir le nom de classe et etc.) en PHP5?

Question

Je remarque que certains frameworks PHP, tels que Kohana et CodeIgniter regarderaient le nom de classe d'une classe pour effectuer le chargement automatique. Traditionnellement, RTTI est cher pour C++; combien il est coûteux pour PHP5, par rapport à:

1. Un appel de message direct
2. Vous cherchez une clé dans un tableau associatif
3. Faire un appel de message via des variables ($ class = 'foobar'; $ method = 'foo'; $ class -> $ method())

Answer 1

En général, si vous utilisez PHP, la performance ne devrait pas être votre plus gros souci, écrivez d'abord un code attrayant (c'est-à-dire lisible et maintenable, auto-documenté, etc.) puis optimisez votre profil. Si vous commencez par vous soucier de la vitesse, PHP n'est probablement pas la solution.

Mais pour répondre à votre question ... get_class a des performances assez décentes, je pense que c'est plutôt bien optimisé dans le moteur zend. essayer d'appeler une fonction non-existante et traitant de l'erreur est beaucoup plus cher. (C'est une erreur fatale d'appeler une fonction inexistante, vous ne pouvez l'attraper que si vous écrivez un tas de code de colle dans votre objet de base)

Voici un peu de benchmarking pour montrer certaines des différentes méthodes de déterminer la capacité à exécuter une méthode.

benchmark.php:

<?php 

class MyClass { 
    public function Hello() { 
     return 'Hello, World!'; 
    } 
} 

function test_get_class($instance) { 
    $t = get_class($instance); 
} 

function test_is_callable($instance) { 
    $t = is_callable($instance, 'Hello'); 
} 

function test_method_exists($instance) { 
    $t = method_exists($instance, 'Hello'); 
} 

function test_just_call($instance) { 
    $result = $instance->Hello(); 
} 

function benchmark($iterations, $function, $args=null) { 
    $start = microtime(true); 
    for($i = 0; $i < $iterations; $i ++) { 
     call_user_func_Array($function, $args); 
    } 
    return microtime(true)-$start; 
} 

$instance = new MyClass(); 

printf("get_class:  %s\n", number_format(benchmark(100000, 'test_get_class', array($instance)), 5)); 
printf("is_callable: %s\n", number_format(benchmark(100000, 'test_is_callable', array($instance)), 5)); 
printf("method_exists: %s\n", number_format(benchmark(100000, 'test_method_exists', array($instance)), 5)); 
printf("just_call:  %s\n", number_format(benchmark(100000, 'test_just_call', array($instance)), 5)); 

?> 

résultats:

get_class:  0.78946 
is_callable: 0.87505 
method_exists: 0.83352 
just_call:  0.85176 

Answer 2

La raison pour laquelle RTTI coûte cher en C++ est que vous devez avoir l'étape supplémentaire de recherche (vtable par exemple). Prenez l'appel de fonction comme exemple. Il en résulte beaucoup plus lent que de déplacer le registre du compteur de programme vers une adresse mémoire qui héberge le code de fonction.

Je n'ai pas vu la mise en œuvre du moteur PHP, mais je soupçonne que comme il a besoin de comprendre la langue d'interprétation, ce « frais généraux » est soit un must (étant donné qu'il ne compile pas le programme, où appeler la fonction de toute façon), ou est minime par rapport à tous les autres frais généraux d'une langue d'interprétation. Cela dit, la meilleure façon d'enquêter est de faire une expérience simple et de profiler le résultat. Vous pouvez avoir deux programmes, l'un utilise RTTI pour faire des appels de fonction, et l'autre utilise des appels directs, et compare les résultats des deux.