Performances d'accès aux fichiers

[Benjamin Delespierre]

Bonjour à tous.

Les grinds de Xdebug ont montré une large faiblesse de performances de la fonction file_exists que depuis je n'utilise pratiquement plus pour le chargement de fichier PHP, je préfère leur substituer cette forme:

Code :

return @include "my_file.php";

au lieu de

Code :

1
2
3
if (file_exists("my_file.php")) {
  return include "my_file.php";
}

Selon vous, laquelle des deux est la meilleure façon de faire d'un point de vue des performances ?

[s.n.a.f.u]

Bonjour,

En termes de perfs, je n'ai pas testé.

Mais je ne pense pas que ce soit une bonne pratique de désactiver les erreurs. Ca ouvre la porte aux bugs, non ?

Comment gérer l'absence du fichier ?

[Benjamin Delespierre]

La directive include renvoie un booléen

[nextdev]

Salut,
Il me semble que is_file est plus rapide que file_exists.
Par contre utiliser @ ralentira malheureusement ton script...

[Benjamin Delespierre]

Envoyé par nextdev

Salut,
Il me semble que is_file est plus rapide que file_exists.
Par contre utiliser @ ralentira malheureusement ton script...

C'est effectivement ce que je crains...

La seule solution reste de benchmarquer les différentes possibilités. C'est parti !

[Benjamin Delespierre]

Bon voici un premier jet:

PHP 5.2

Code :

1
2
3
4
5
6
7
8
9
1 scenario ran with 1000 iterations
 
>> Scenario 1
........Test Name........ | ..........Time........... | ....Ms.... | ..Performance.. | 
file_exists               | 0.36196899414062          |   361.97ms |            100% | 
is_file                   | 0.039561986923218         |    39.56ms |            915% | 
is_writable               | 0.353924036026            |   353.92ms |            102% | 
include                   | 0.49230599403381          |   492.31ms |             74% | 
@include                  | 0.49788403511047          |   497.88ms |             73% |

PHP 5.3

Code :

1
2
3
4
5
6
7
8
9
1 scenario ran with 1000 iterations
 
>> Scenario 1
........Test Name........ | ..........Time........... | ....Ms.... | ..Performance.. | 
file_exists               | 0.026853084564209         |    26.85ms |            100% | 
is_file                   | 0.0063860416412354        |     6.39ms |            420% | 
is_writable               | 0.035054922103882         |    35.05ms |             77% | 
include                   | 0.18422913551331          |   184.23ms |             15% | 
@include                  | 0.17658400535583          |   176.58ms |             15% |

Testé sous Windows XP avec WampServer, Apache 2.2.

Ces résultats sont à prendre avec des pincettes, certaines fonctions comme file_exists utilisent un cache pour améliorer les performances.
A noter tout de même qu'on remarque une très nette amélioration des performances avec is_file (jusqu'a x10) et que le fait de désactiver les erreurs ne joue pas (ou peu) sur la directive include.

Le code des scenarios:

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
<?php
 
// Fixtures
define("ITERATIONS", 1000);
set_time_limit(-1);
set_include_path('.');
 
/**
 * Perfomance Test 1.1
 * -------------------
 * Study Case: default "file_exists" implementation
 */
function bench_1_1 () {	
    $t = microtime(true);
    $i = 0;
    while(($i++) < ITERATIONS) {
        $result = file_exists('my_file.php');
    }
    return (microtime(true) - $t);
}
 
/**
 * Perfomance Test 1.2
 * -------------------
 * Study Case: default "is_file" implementation
 */
function bench_1_2 () {
	$t = microtime(true);
	$i = 0;
	while (($i++) < ITERATIONS) {
		$result = is_file('my_file.php');
	}
	return (microtime(true) - $t);
}
 
/**
 * Performance Test 1.3
 * --------------------
 * Study Case: default "is_writable" implementation
 */
function bench_1_3 () {
	$t = microtime(true);
	$i = 0;
	while (($i++) < ITERATIONS) {
		$result = is_writable('my_file.php');
	}
	return (microtime(true) - $t);
}
 
/**
 * Performance Test 1.4
 * --------------------
 * Study Case: simple inclusion
 */
function bench_1_4 () {
	$t = microtime(true);
	$i = 0;
	while (($i++) < ITERATIONS) {
		$result = include 'my_file.php';
	}
	return (microtime(true) - $t);
}
 
/**
 * Performance Test 1.5
 * --------------------
 * Study Case: inclusion with error disabled
 */
function bench_1_5 () {
	$t = microtime(true);
	$i = 0;
	while (($i++) < ITERATIONS) {
		$result = @include 'my_file.php';
	}
	return (microtime(true) - $t);
}
 
//       //
// START //
//       //
 
$r = array(1 => array());
 
// You may change order here
$r[1][1] = array('file_exists', bench_1_1());
$r[1][2] = array('is_file',     bench_1_2());
$r[1][3] = array('is_writable', bench_1_3());
$r[1][4] = array('include',     bench_1_4());
$r[1][5] = array('@include',    bench_1_5());
 
header('Content-Type: text/plain');
echo count($r) . ' scenario ran with ' . ITERATIONS . ' iterations' . "\n\n";
 
foreach ($r as $id => $scenario) {
	echo ">> Scenario {$id}\n";
	echo str_pad("Test Name",   25, ".", STR_PAD_BOTH) . ' | ' . 
		 str_pad("Time",        25, ".", STR_PAD_BOTH) . ' | ' .
		 str_pad("Ms",          10, ".", STR_PAD_BOTH) . ' | ' . 
		 str_pad("Performance", 15, ".", STR_PAD_BOTH) . ' | ' . 
		 "\n";
	foreach ($scenario as $result) {
		echo str_pad($result[0], 25) . ' | ' . 
			 str_pad($result[1], 25) . ' | ' . 
			 str_pad(round($result[1] * 1000, 2) . 'ms', 10, " ", STR_PAD_LEFT) . ' | ' . 
			 str_pad(round(($scenario[1][1] / $result[1]) * 100, 0) . '%', 15, " ", STR_PAD_LEFT) . ' | ' . 
			 "\n";
	}
}

[Bisûnûrs]

J'avais déjà fait le test de performance entre file_exits() et @include() il y a quelques temps (on a d'ailleurs développé une page spéciale pour faire des benchs là où je bosse), et je ne trouve bizarrement pas les même résultats que toi :



C'est sans compter le cache de la fonction file_exists(), donc si on utilise clearstatcache() avant chaque appel, pour tester les performances réelles, on voit que la fonction file_exits() est encore moins performante.

[nextdev]

Alors ça... c'est du sacré bench

Nous manque juste un petit avec php4, et c'est peu etre d'ailleurs sous php4 que le @ fait chutter.

Sympa le gain is_file en php5 ! je suis pas sur qu'il soit aussi énorme en 4.

[nextdev]

Tu obtiens quoi Bisûnûrs avec ce test :

Code :

1
2
3
4
5
6
7
8
if((@include($fichier))!==false) {
}
 
//vs
 
if(is_file($fichier)) {
include($fichier);
}

Sur quel version de php tu es ?
Le fichier txt est bien présent ?

[Benjamin Delespierre]

Je précise que j'ai effectué mes tests sans clearstatcache() sur une machine windows (Intel Core 2 Duo à 2.26ghz) et avec un fichier existant.

Tu remarquera par ailleurs que mes tests sont sensiblement différents de ceux que tu as effectué car les miens ne servent qu'a tester atomiquement la reconnaissance d'un fichier.

Ce qui m'intéresse c'est surtout de savoir quelle est la meilleure option pour détecter la présence ou non d'un fichier.

[Bisûnûrs]

Envoyé par nextdev

Tu obtiens quoi Bisûnûrs avec ce test :

Code :

Version fichier inexistant :

(code 1 = include, code 2 = is_file)

Version fichier existant :

(code 1 = include, code 2 = is_file)

Envoyé par nextdev

Sur quel version de php tu es ?
Le fichier txt est bien présent ?

Dans le premier message, c'était avec un fichier inexistant.

Sinon, c'est :
- PHP 5.3.2 ;
- Intel(R) Xeon(R) CPU W3520 @ 2.67GHz, 8 cores ;
- 12Go de RAM

Envoyé par Benjamin Delespierre

Ce qui m'intéresse c'est surtout de savoir quelle est la meilleure option pour détecter la présence ou non d'un fichier.

Le problème c'est que même si l'include te renvoie la valeur que tu souhaites, les fichier est inclus quoi qu'il arrive.

[Benjamin Delespierre]

Le problème c'est que même si l'include te renvoie la valeur que tu souhaites, les fichier est inclus quoi qu'il arrive.

Peu importe puisqu'il s'agit dans mon cas d'inclure des fichiers PHP.

Quand j'ai constaté dans mes grinds que l'Autoloader prennait entre 15% et 25% du temps d'execution total, j'ai pris peur...

En tout cas merci bisunurs d'avoir effectué ces benchmarks, ça me permet de répondre à ma question

PS: Ton outil de benchmark est disponible quelque part sur la toile ?

[s.n.a.f.u]

Envoyé par Benjamin Delespierre

Peu importe puisqu'il s'agit dans mon cas d'inclure des fichiers PHP.

Ben oui, mais c'est là que les tests ne sont pas relevants : puisqu'après le test file_exists ou autre, tu vas de toute façon utiliser include.

Il faudrait tester les enchainements test_d_existence+inclusion.

[Bisûnûrs]

Envoyé par Benjamin Delespierre

Peu importe puisqu'il s'agit dans mon cas d'inclure des fichiers PHP.

Envoyé par s.n.a.f.u

Ben oui, mais c'est là que les tests ne sont pas relevants : puisqu'après le test file_exists ou autre, tu vas de toute façon utiliser include.

Il faudrait tester les enchainements test_d_existence+inclusion.

Voilà. D'où mon premier test qui avait été fait avec include() vs file_exists()+include().

Envoyé par Benjamin Delespierre

PS: Ton outil de benchmark est disponible quelque part sur la toile ?

Non, pas encore, j'avais prévu de le déporter à l'époque où je le développais, mais il a pas mal été amélioré depuis, notamment par RideKick, donc je vais voir avec lui ce qu'on peut faire.

[nextdev]

J'ai fait le test sur php 4.3 et c'est un peu du genre les votres, sauf pour le gain is_file vs file_exists tres petit...

A : is_file
B : file_exists
C : if(is_file(./test.php)) { include(./test.php); }
D : if(@include(./test.php))!==false) {}
E : @include
F : include

A: 0.00184 s
B: 0.00157 s
C: 0.34811 s
D: 0.36105 s
E: 0.39377 s
F: 0.28415 s

A: 0.00157 s
B: 0.00193 s
C: 0.39129 s
D: 0.29325 s
E: 0.33588 s
F: 0.36853 s

A: 0.00156 s
B: 0.00196 s
C: 0.37584 s
D: 0.31348 s
E: 0.27019 s
F: 0.35940 s

A: 0.00159 s
B: 0.00160 s
C: 0.29865 s
D: 0.35581 s
E: 0.34903 s
F: 0.38550 s

A: 0.00157 s
B: 0.00162 s
C: 0.35654 s
D: 0.30475 s
E: 0.37011 s
F: 0.27952 s

(un peu préhistorique, mais fiable, machine un peu sollicité, ton bench Benjamin fait des trucs bizarre sous mon php4, tps négatifs)

Au final, is_file, c'est bien juste pour tester l'existence, mais ça sers "a rien" si tu compte inclure ce fichier.

Sinon le coup du @include est pas si mal en fait (surtout php5)

Je pense que ton "probleme" de tps d'execution viens de autre chose que ces includes...

A quoi servent ces tests include ? il y en a beaucoup ?

[Benjamin Delespierre]

ton bench Benjamin fait des trucs bizarre sous mon php4, tps négatifs

Microtime n'est capable de renvoyer des floats que depuis PHP 5, voir la doc.

Je pense que ton "probleme" de tps d'execution viens de autre chose que ces includes...

Je n'ai pas de "problème" avec le temps d'execution, je cherche à optimiser c'est tout.

A quoi servent ces tests include ? il y en a beaucoup ?

A chaque chargement de classe vu qu'il s'agit d'un autoloader.

Bon on gagnera sûrement du temps en vous proposant de tester cette librairie par vous-même:

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
<?php
/**
 * PHP AXIOM
 *
 * @license LGPL
 * @author Benjamin DELESPIERRE <benjamin.delespierre@gmail.com>
 * @category libAxiom
 * @package library
 * $Date: 2011-09-13 15:12:32 +0200 (mar., 13 sept. 2011) $
 * $Id: Autoloader.class.php 25525 2011-09-13 13:12:32Z delespierre $
 */
 
/**
 * Autoloader Class
 *
 * @author Delespierre
 * @version $Rev: 25525 $
 * @subpackage Autoloader
 */
class Autoloader {
 
    /**
     * Autoloader contfig
     * @var array
     */
    protected static $_config = array();
 
    protected static $_al_registered;
 
    /**
     * Set the Autoload configuration
     * @param array $config = array()
     * @return void
     */
    public static function setConfig ($config = array()) {
        $default = array(
            'paths' => array(
                APPLICATION_PATH . '/controller',
                APPLICATION_PATH . '/model',
                LIBRARY_PATH,
                LIBRARY_PATH . '/exceptions',
                LIBRARY_PATH . '/helpers',
                LIBRARY_PATH . '/loggers',
                LIBRARY_PATH . '/feeds',
				LIBRARY_PATH . '/uploader',
            ),
            'extension' => '.class.php',
        );
 
        self::$_config = array_merge_recursive($default, $config);
    }
 
	/**
     * Add a path to the autoloader and return it.
     *
     * Note: you must start the autoloader when calling this
     * method or the changes since the last 'start' invocation
     * will not be effective.
     *
     * @param string $path
     * @param string $name = null
     * @throws RuntimeException
     * @return boolean
     */
    public static function add ($path) {
        if (!file_exists($path))
            throw new RuntimeException("Path $path not found", 2044);
 
        return self::$_config['paths'][] = $path;
    }
 
    /**
     * Start auloading handle.
     * Will return the spl_autoload_register status.
     * @param array $paths = array()
     * @return boolean
     */
    public static function start ($paths = array()) {
        $include_path = array_unique(array_merge(self::$_config['paths'], explode(PATH_SEPARATOR, get_include_path())));
 
        if (set_include_path(implode(PATH_SEPARATOR, $include_path)) === false)
            throw new RuntimeException("Could not register the new include path", 2045);
 
        return spl_autoload_register(array(__CLASS__, 'load'));
    }
 
    /**
     * Prevent the autoloader to load classes.
     *
     * This method may be useful if you have
     * a custom autoloader or if you're using
     * another framework.
     *
     * Note: the include path previously set
     * by Autoloader::start is preserved.
     *
     * @return boolean
     */
    public static function stop () {
        return spl_autoload_unregister(array(__CLASS__, 'load'));
    }
 
    /**
     * Load the give class.
     *
     * Will return true if the class file
     * was successfuly loaded, false otherwise
     *
     * EG: Autoloader::load('MyRandomClass');
     *
     * Note: The autoloader will seek for a
     * file named MyRandomClass.class.php,
     * this extension may be set manualy in
     * Autoloader::setConfig.
     *
     * @param string $class
     * @return boolean
     */
    public static function load ($class) {
        return @include $class . self::$_config['extension'];
    }
}

[stealth35]

utilise spl_autoload (et spl_autoload_extensions pour géré ton extension)

edit : d'ailleurs vus que les classes sont seules, pas besion de faire ton autoload custom, c'est déjà résolu avec le path

[Benjamin Delespierre]

Effectivement c'est une solution. En revanche je perd la possibilité d'arrêter l'autoloader mais c'est pas tellement utile de toute façon.

Il faudra alors que je remplace tous les appels Autoloader::load($c) par des class_exists (à ma connaissance y'en a qu'un: au moment de la sélection du contrôleur).

Est-ce qu'il y a un gain de perfs à la clé ?

[stealth35]

t'as pas besoin de charger les classes avec Autoloader::load, si la classe n'existe pas l'autoloader va la chargé comme un grand

[Benjamin Delespierre]

Dans le cas cité plus haut, il s'agit de valider l'existence ou non d'une classe, j'aurais dû le préciser.