PHP optimieren

Bei Jan Piotrowski habe ich heute morgen eine sehr umfassende Linksammlung für das Optimieren von PHP Anwendungen gefunden. Die Liste enthält zwar "nur" 8 Links, diese haben es aber teilweise in sich, will heißen, sie sind teilweise ziemlich umfangreich. Da brauche ich sicher ein paar Stunden, um mich dort einmal durchzuarbeiten.

Zwei weitere Tipps fallen mir auch noch auf die Schnelle ein (auch wenn ich nicht weiß, ob sie nicht vielleicht schon in den Links behandelt werden.

1. Array-Daten serialisiert laden

Vor vielen Monden habe ich einmal ein Benchmark für das Laden von größeren Arrays aus PHP Dateien durchgeführt. Neben einem einfachen include() bzw. require() habe ich auch getestet, wie schnell serialisierte Daten geladen und wieder deserialisiert werden. Dabei habe ich heraus gefunden, dass das Laden eines serialisierten Arrays aus einer Textdatei deutlich schneller vonstatten geht, als das Laden eines normalen Arrays aus einer PHP Datei.

Beispiel für ein nicht serialisiertes Array:

Quellcode (klicken)
PHP:
  1. <?php
  2.     $_dobDef["main"]["dobFile"    ] = "dob/user/main_edit.php";
  3.     $_dobDef["main"]["dobName"    ] = "dobUserMainEdit";
  4.     $_dobDef["main"]["dobPkey"    ] = "um_id";
  5.     $_dobDef["main"]["dobDataFunc"] = "updateActivation";
  6.     $_dobDef["main"]["transArea"  ] = "dob_user_main";
  7.     $_dobDef["main"]["caching"    ] = false;
  8. ?>

Nach der Serialisierung sehen die Daten dann so aus:

Quellcode (klicken)
CODE:
  1. a:1:{s:4:"main";a:6:{s:7:"dobFile";s:22:"dob/user/main_edit.php";s:7:"dobName";s:15:"dobUserMainEdit";s:7:"dobPkey";s:5:"um_id";s:11:"dobDataFunc";s:16:"updateActivation";s:9:"transArea";s:13:"dob_user_main";s:7:"caching";b:0;}}

Das Laden dieser serialisierten Daten funktioniert fast so einfach wie ein include() bzw. require():

Quellcode (klicken)
PHP:
  1. unserialize(implode("", file($inFile)));

Das einzige Problem ist, dass man diese Datenfiles nach jeder Änderung erst einmal wieder serialisieren muss. Ich habe mir dafür ein kleines Skript geschrieben, welches ich dann nach dem Ändern der Daten einmal ausführen muss. Ich denke, dieser extra Verwaltungsaufwand ist die Performancesteigerung durchaus wert:

Quellcode (klicken)
PHP:
  1. <?php
  2.     /**
  3.     * Convert definition files.
  4.     *
  5.     * This script helps to convert the table, tree and form definition files.
  6.     * The files contain serialized data arrays, which can be loaded and
  7.     * unserialized for usage in scripts. Loading and unserialization is much
  8.     * quicker than the inclusion of an array declaration in a php script file.
  9.     *
  10.     * @author Ralf Eggert <ralf@travello.de>
  11.     * @copyright Copyright 2003 - 2004, Ralf Eggert
  12.     * @version 0.3
  13.     * @package Data definition files
  14.     */
  15.  
  16.     /**
  17.     * Load configuration file
  18.     */
  19.     require_once("cfg/admin.php");
  20.    
  21.     /**
  22.     * Set some variables for
  23.     */
  24.    
  25.     $locDefTypeList = array("table"    => "_tableDef",
  26.                             "tree"     => "_treeDef",
  27.                             "relation" => "_relDef",
  28.                             "form"     => "_formDef",
  29.                             "list"     => "_listDef",
  30.                             "view"     => "_viewDef",
  31.                             "dob"      => "_dobDef",
  32.                             "misc"     => "_miscDef",
  33.                             "lang"     => "_langDef",
  34.                             "filter"   => "_filterDef",
  35.                             "keylist"  => "_keylistDef",
  36.                             "mail"     => "_mailDef");
  37.    
  38.     $locDestDir     = "def/files/";
  39.     $locSrcDir      = "def/source/";
  40.     $locSrcFileList = array();
  41.    
  42.     /**
  43.     * Fetch list of all files in definition directory
  44.     */
  45.    
  46.    
  47.     foreach ($locDefTypeList as $locKey => $locVal)
  48.     {
  49.         $locSrcHandle   = @opendir($_config["path"]["phppath"] . $locSrcDir . $locKey . "/");
  50.        
  51.         while ($locSrcFile = @readdir($locSrcHandle))
  52.         {
  53.             if (eregi("^\.{1,2}$", $locSrcFile))
  54.             {
  55.                 continue;
  56.             }
  57.             elseif (".svn" == $locSrcFile)
  58.             {
  59.                 continue;
  60.             }
  61.            
  62.             $locSrcFileList[] = $locKey . "/" . $locSrcFile;
  63.         }
  64.         
  65.         @closedir($locSrcHandle);
  66.     }
  67.    
  68.     sort($locSrcFileList);
  69.    
  70.     /**
  71.     * Clear all def type variables
  72.     */
  73.     foreach ($locDefTypeList as $locDefType)
  74.     {
  75.      unset($$locDefType);
  76.     }
  77.    
  78.     /**
  79.     * Process Source File list
  80.     */
  81.     foreach ($locSrcFileList as $locSrcFile)
  82.     {
  83.         /**
  84.         * Get Definition Type
  85.         */
  86.         $locDefType    = explode("/", $locSrcFile);
  87.         $locDefFileDir = $locDefType[0];
  88.         $locDefType    = $locDefTypeList[$locDefFileDir];
  89.        
  90.         if (file_exists($_config["path"]["phppath"] . $locSrcDir . $locSrcFile))
  91.         {
  92.             include($locSrcDir . $locSrcFile);
  93.            
  94.             if (isset($$locDefType))
  95.             {
  96.                 $locDestFile   = $locDestDir . $locSrcFile;
  97.                    
  98.                 /**
  99.                 * Open file for writing 
  100.                 */
  101.                 $locFile = $_config["path"]["phppath"] . $locDestFile;
  102.                 $locFw   = fopen($locFile, "w");
  103.                
  104.                 /**
  105.                 * Serialize data array 
  106.                 */
  107.                 $locText = serialize($$locDefType);
  108.                
  109.                 /**
  110.                 * Wrote data and close file 
  111.                 */
  112.                 fwrite($locFw, $locText);
  113.                 fclose($locFw);
  114.                 
  115.                 /**
  116.                 * Unset data array 
  117.                 */
  118.                 unset($$locDefType);
  119.  
  120.                 echo "Conversion of definition file \"{$locSrcFile}\" <B>ok</B>!<br />\n";
  121.             }
  122.             else
  123.             {
  124.                 echo "Conversion of definition file \"{$locSrcFile}\" <B>failed</B>!<br />\n";
  125.             }
  126.         }
  127.     }
  128. ?>

Ich habe das Skript jetzt nicht extra überarbeitet und optimiert. Es tut bereits seit Jahren seine Dienste. Einziger Hinweis: in $_config["path"]["phppath"] steht der Pfad zu allen PHP Dateien. Darunter befinden sich dann das Quellverzeichnis "def/source/" und das Verzeichnis mit den serialisierten Daten "def/files/".

Letzter Hinweis: die Benchmarks hierfür habe ich vor einigen Jahren unter PHP4 durchgeführt. Ob sich an diesem Verhalten mittlerweile etwas geändert hat, müsste ich noch einmal im Detail nachprüfen.

2. xdebug für das Profiling nutzen

Ein anderer Tipp stammt aus dem Buch "Enterprise PHP Tools", das ich vor einigen Tagen vorgestellt habe. Mit Hilfe der Profiling Funktionen von xdebug kann man detailliert überprüfen, welche Programmteile welche Laufzeit beanspruchen. So kann man schnell die Langläufer ausfindig machen und dort mit der Optimierung ansetzen.

Die etwas schwer zu lesenden Profiling Dateien, die xdebug erstellt, kann man mit Hilfe der Tools KCacheGrind (für Linux) und WinCacheGrind für Windows visualisieren.

Ich habe das selber noch nicht im Detail ausprobiert. Das steht aber ganz oben auf meinem Zettel. xdebug bietet zusätzlich zum Profiling noch viele andere nützliche Funktionen, die einem das Optimieren von PHP Code vereinfachen.

Dieser Beitrag wurde geschrieben am Montag, 28.08.2006, um 07:47 und wurde abgelegt unter Zend Framework. Du kannst alle Antworten für diesen Beitrag über den RSS 2.0 Feed verfolgen. Du kannst eine Antwort schreiben oder einen Trackback von deiner Site setzen.

7 Antworten für “PHP optimieren”

  1. Jan sagt:
    Montag, 28.08.2006, um 12:06

    Xdebug2 ist wirklich absolut zu empfehlen. Wenn man nicht gerade komplett auf Funktionen und Includes verzichtet liefert es eine Menge wertvoller Hinweise. Aber nicht vergessen nach dem Profiling das Modul wieder zu deaktivieren, es kostet doch einiges an Zeit bei der Scriptsausführung.

  2. Ralf Eggert sagt:
    Dienstag, 29.08.2006, um 10:40

    Hi Jan,

    ja, das ist klar, wenn man dauernd alle Optionen von xdebug aktiviert, dann macht das Entwickeln kaum noch Spass. Man hat dann aber viele Daten, die man auswerten könnte, wenn man mal Langeweile hat... ;-)

    Gruß,

    Ralf

  3. Sebastian sagt:
    Dienstag, 29.08.2006, um 12:51

    Hallo Ralf,

    ich verstehe gerade nicht, warum du beim unserialize einen implode machst.

  4. Ralf Eggert sagt:
    Dienstag, 29.08.2006, um 13:05

    Hallo Sebastian,

    unserialize(implode("", file($inFile)));

    Das file($inFile) läft die gesamte Datei in ein Array, wobei für jede Textzeile ein Eintrag im Array vorhanden ist. Weil unserialize() aber einen String benötigt, füge ich die Arrayelemente per implode() wieder zu einem String zusammen.

    Gruß,

    Ralf

  5. Sebastian sagt:
    Dienstag, 29.08.2006, um 13:17

    Witzig, ich habe file gelesen und file_get_contents gedacht. Ich glaub ich sollte einen Kaffe trinken. :)

  6. Ralf Eggert sagt:
    Dienstag, 29.08.2006, um 13:21

    Stimmt, file_get_contents() würde an der Stelle viel mehr Sinn machen. Wie gesagt, habe ich das vor einigen Jahren mal so eingerichtet und seitdem nicht mehr angefasst, äh optimiert ;-)...

    Gruß,

    Ralf

  7. Martin sagt:
    Donnerstag, 12.10.2006, um 23:24

    Bei meinen Tests in PHP 5.1.4 unter Windows kam ich immer zu dem eindeutigen Ergebnis, dass die Verwendung von serialisierten Arrays wesentlich langsamer ist, als die konventionelle Schreibweise. Etwas schneller als die übliche Variante ist die Schreibweise, die var_export() erzeugt. unserialize() braucht etwa dreimal soviel Zeit. Dateioperationen hab ich dabei allerdings nicht benutzt, sondern habe alles in eine einzige Datei geschrieben. Vielleicht ist der Flaschenhals eher bei include() (vs. file_get_contents()) zu suchen.

    Generell denke ich, man sollte sich bei der Optimierung nicht zu sehr zum Sklaven der Technik machen lassen (CPU-Zeit dürfte auch günstiger sein als menschliche Arbeitszeit), zumal manche Geschwindigkeitsvorteile auch in zukünftigen Versionen hinfällig sein könnten. Solange es nicht um besonders zeitkritische Anwendungen geht, halte ich sauberen Code für wichtiger.

Hinterlasse eine Antwort