Skip to the content
Documentation
Help Start
Reading in:
  • German: 9,090 of 9,090 pages
About the help in other languages
All help pages

Smarty-Templates: Leistung (Geschwindigkeit)

Diese Seite ist für Template-Entwickler, Site-Bauer und Betreiber, die schnelle .stpl-Seiten möchten, und für alle, die wissen wollen, warum sie schnell sind. Sie erzählt die ganze Geschichte, wie Smarty-Templates in…

Download as PDF

Address: https://doc.exponential.earth/exphelp/viewer/guides/smarty-templates-performance.md

On this page

This page is a translation. Read the English original

Smarty-Templates: Leistung (Geschwindigkeit)

Diese Seite ist für Template-Entwickler, Site-Bauer und Betreiber, die schnelle .stpl-Seiten möchten, und für alle, die wissen wollen, warum sie schnell sind. Sie erzählt die ganze Geschichte, wie Smarty-Templates in Exponential schnell wurden: was anfangs langsam war und warum, jede Änderung, die vorgenommen wurde, mit ihrem Grund, eine Änderung, die bewusst nicht vorgenommen wurde, die Zahlen vorher und nachher, was jede Cache-Ebene beiträgt, das Seiten-Cache-Muster der Media-Portierung, wie man misst, ohne sich selbst zu täuschen, wie sich Velocity und PHP-FPM unterscheiden, die Einstellungen, auf die es ankommt, eine Checkliste und eine Liste von Fallstricken.

Alle Zahlen auf dieser Seite wurden am 28. Oktober 2026 auf einer Entwicklungsinstallation gemessen, mit dem Media-Design (das .tpl-Original in extension/sevenx_themes_media/design/media/ und seine Smarty-Portierung in .../design/smarty_media/, 516 Templates), ausgeliefert von zwei Siteaccesses, die denselben Inhalt zeigen: site mit dem .tpl-Design und smarty mit dem .stpl-Design. Die Adressen unten verwenden https://www.example.com.

Weiterführend: Caching und Leistung (die Cache-Ebenen als Referenz) und die Funktionsseite Smarty-Templates (.stpl) neben .tpl.

Kurz gesagt

  • Eine .stpl-Seite ist jetzt schneller als dieselbe .tpl-Seite: 18 bis 25 % auf Apache mit PHP-FPM, 32 bis 60 % auf Velocity, bei Byte für Byte identischem HTML.
  • Anfangs war sie viel langsamer. Jedes von einem .stpl eingebundene .stpl ging den ganzen Weg durch das Template-System und startete ein neues Smarty-Rendern, bei dem jede Variable umgewandelt und zurückgeschrieben wurde; eine Startseite tat das 266-mal.
  • Sechs Änderungen machten den Unterschied: Einbindungen als Smarty-Subtemplates, eine Smarty-Instanz pro Satz von Designs, Werte einmal pro Seite umgewandelt, unveränderte Variablen nicht zurückgeschrieben, Namensauflösungen pro Prozess gemerkt und das Zurückschreiben in einen Post-Filter verlegt. Operatoraufrufe wurden gemessen und so belassen: Sie waren günstig.
  • Der größte einzelne Gewinn für echte Besucher ist das Caching: Die Media-Portierung hält ihr ganzes Pagelayout in einem {expcacheblock} und rendert nur das eigene Benutzermenü des Besuchers frisch, was die meisten Velocity-Anfragen auf 0,03 bis 0,07 s brachte.
  • Messen Sie sorgfältig: die Skriptzeit der Debug-Leiste, der Median von zehn Anfragen, dieselben Caches und derselbe Debug-Zustand für beide Engines und ein Server, der nicht überlastet ist.

Die Ergebnisse

Gemessen mit der Skriptzeit der Debug-Leiste, dem Median von 10 Anfragen je Seite, mit warmem Content-View-Cache und eingeschalteter Debug-Leiste für beide Engines; der .tpl- und der .stpl-Siteaccess zeigten Byte für Byte dasselbe HTML.

Seite.tpl, Apache + PHP-FPM.stpl, Apache + PHP-FPM.tpl, Velocity.stpl, Velocity
Eine Kategorieseite (/fitness)0,119 s0,097 s (18 % schneller)0,102 s0,069 s (32 % schneller)
Eine Rezeptliste (/recipes)0,102 s0,077 s (25 % schneller)0,093 s0,037 s (60 % schneller)
Die Startseite—0,104 s—0,036 s
  • Die .tpl-Startseite wurde in diesen Läufen aus dem Ganzseiten-Cache beantwortet und hatte daher keine eigene Skriptzeit zum Vergleich (siehe warum unten).
  • Allein in der Template-Verarbeitung (dem Akkumulator der Leiste) brauchte die .stpl-Kategorieseite 74 ms gegenüber 90 ms für die .tpl-Seite, mit 14 MB Speicher gegenüber 18 MB.
  • Viele .stpl-Anfragen auf Velocity wurden in 0,024 bis 0,040 s beantwortet.

Die Zahlen hängen von der Last des Servers und von seiner Hardware ab; was sich auf eine andere Installation übertragen lässt, ist das Verhältnis, und auch das nur, wenn beide Engines unter identischen Bedingungen gemessen werden.

Wo es begann: warum .stpl anfangs langsam war

Die erste funktionierende Version renderte jedes .stpl korrekt, und zwar langsam: Die Smarty-Seiten waren viel langsamer als die .tpl-Seiten, aus denen sie konvertiert wurden. Das Profil einer Startseite zeigte, wo die Zeit blieb.

Befund auf einer StartseiteAnzahl oder Kosten
Vollständige Rendervorgänge über die Brücke266
Operatoraufrufe über die Brücke5.483
Suchen der Smarty-Instanz (expSmartyRenderer::smarty()): die Template-Verzeichnisse auf der Platte geprüft und die Einstellungen gehasht, bei jedem Rendernetwa 1,7 ms pro Aufruf
Umwandeln jeder Variablen des Namensraums für Smarty (wrap()) bei jedem Rendernetwa 190 ms auf dieser Seite unter Last
Zurückschreiben jeder Variablen nach jedem Rendern, jede tief mit ihrem alten Wert verglichen (writeBack())etwa 240 ms auf dieser Seite unter Last

Die Ursache war bei allen dieselbe: Jedes von einem .stpl eingebundene .stpl war ein vollständiges Rendern. Die Einbindung ging von Smarty zum Template-System ({expinclude}), das die Datei über die Design-Ressource lud, ein .stpl fand, dessen Stub {exp_smarty_render( '<file>' )} zurückgab, den Stub ausführte, der expSmartyRenderer::render() aufrief, das die Smarty-Instanz suchte, jede Variable des Namensraums in Smarty-Werte umwandelte (Objekte in Proxys, Arrays Element für Element durchlaufen), ein neues Smarty-Template anlegte, es abrief und dann jede Variable noch einmal durchlief, um zurückzuschreiben, was sich geändert hatte. Eine Seite aus 37 Smarty-Templates wurde zu 266 Rendervorgängen, von denen jeder all das bezahlte.

Was geändert wurde, und warum

1. Ein von einem .stpl eingebundenes .stpl ist ein Smarty-Subtemplate

Wenn {expinclude} ohne name= verwendet wird (das eingebundene Template teilt sich den Namensraum des einbindenden, wie bei einem .tpl-{include}), fragt die Brücke zuerst die Design-Ressource, für welche Datei die URI steht, ohne sie zu laden, und rendert diese Datei, wenn sie ein .stpl ist, als Smarty-Subtemplate des einbindenden Templates.

lib/smarty/classes/expsmartyincludefunction.php:

// A .stpl in the shared namespace runs as a Smarty subtemplate of this one: the same file the template
// system would load (the design resource, its override rules and keys), the same variables, without the
// detour through the template system, its stub and a second render.
if ( $shared )
{
    $file = expSmartyRenderer::resolveURI( $tpl, $uri, $templateName );
    if ( $file !== null && expSmartyRenderer::isSmartyTemplate( $file ) )
        return expSmartyRenderer::renderSubtemplate( $template, $file, $params, $uri, $templateName );
}

expSmartyRenderer::resolveURI() fragt die Ressource mit eZTemplate::RESOURCE_QUERY, dem Modus, in dem die Ressource einen Namen auflöst (Override-Regeln, Design-Fallback, die Design-Schlüssel der Seite) und die Datei zurückgibt, ohne sie zu laden:

$resource = $tpl->resourceFor( $uri, $resourceName, $templateName );
if ( !is_object( $resource ) )
    return null;
$resourceData = $tpl->resourceData( $resource, $uri, $resourceName, $templateName );
$extraParameters = array();
if ( !$resource->handleResource( $tpl, $resourceData, eZTemplate::RESOURCE_QUERY, $extraParameters ) )
    return null;

renderSubtemplate() legt das Kind-Template mit dem einbindenden als Elternteil an, sodass es die Variablen des einbindenden Templates ohne jede Umwandlung sieht, weist die Einbindungsparameter zu, ruft es ab und gibt zurück, was das Kind definiert oder geändert hat, an das Elternteil. Nichts geht durch die Namensräume des Template-Systems.

Warum es richtig ist: Die Datei ist die, die das Template-System geladen hätte (dieselbe Ressource, dieselben Override-Regeln, dieselben Schlüssel), die Variablen sind dieselben, und was die Einbindung definiert, ist danach sichtbar, wie zuvor. Was es brachte: Die Startseite ging von 266 Rendervorgängen über die Brücke auf 37. Bei eingeschalteter Debug-Ausgabe ist jedes Subtemplate weiterhin ein Eintrag im Template-Baum der Debug-Leiste, unter dem Template, das es eingebunden hat.

Eine Einbindung mit name= oder eines .tpl geht weiterhin durch das Template-System, weil dort die Namensräume zählen.

2. Eine Smarty-Instanz pro Satz von Designs

expSmartyRenderer::smarty() wird für jedes .stpl aufgerufen, das eine Seite rendert. Früher prüfte es bei jedem Aufruf jedes Template-Verzeichnis jedes Designs auf der Platte und hashte die Einstellungen. Jetzt wird die Instanz nach den Design-Basen und dem Cache-Verzeichnis gemerkt und mit einem einzigen Array-Zugriff gefunden:

// Called for every .stpl a page renders: the instance of the same design bases and cache directory is
// found without checking the directories and the settings again (an INI change needs a deploy anyway).
$bases = eZTemplateDesignResource::allDesignBases();
$basesKey = eZSys::cacheDirectory() . "\n" . implode( "\n", $bases );
if ( isset( self::$instancesByBases[$basesKey] ) )
    return self::$instancesByBases[$basesKey];

Warum es sicher ist: Die Template-Verzeichnisse ergeben sich aus den Design-Basen, und die Einstellungen, die die Instanz formen (CompileCheck, Debugging, Security und ihre Listen), ändern sich nur mit einem Deploy, der die Worker neu startet. Ein Siteaccess mit anderen Designs bekommt seine eigene Instanz.

3. Werte werden einmal pro Seite umgewandelt

Exponential-Objekte erreichen Smarty als schreibgeschützte Proxys, Arrays Element für Element umgewandelt (wrap()), und gehen ausgepackt zurück (unwrap()). Dasselbe $node, $module_result oder $view_parameters wurde für jedes .stpl der Seite erneut umgewandelt. Jetzt merkt sich die Brücke pro Variablenname das letzte Paar aus rohem und umgewandeltem Wert:

public static function wrapNamed( $name, $value )
{
    if ( isset( self::$pairs[$name] ) && self::$pairs[$name][0] === $value )
        return self::$pairs[$name][1];
    if ( !is_array( $value ) && !is_object( $value ) )
        return $value;
    $wrapped = self::wrap( $value );
    self::$pairs[$name] = array( $value, $wrapped );
    return $wrapped;
}

Warum es schnell ist: === auf demselben Objekt ist ein einziger Zeigervergleich, und bei demselben Array vergleicht PHP zuerst das Array, das es teilt, und das ist bei einer unveränderten Variablen dasselbe Array: Die Antwort steht fest, ohne den Wert zu durchlaufen. unwrapNamed() macht dasselbe in der Gegenrichtung. Die Paare werden verworfen, wenn das äußerste Rendern einer Anfrage endet, sodass nichts von einer Anfrage die nächste erreicht.

4. Unveränderte Variablen werden nicht zurückgeschrieben

Nach einem Rendern schreibt die Brücke zurück, was das Template definiert, geändert oder auf null gesetzt hat, wie es {def}, {set} und {undef} tun. Früher schrieb sie alles zurück. Jetzt wird eine Variable übersprungen, deren Wert der ist, mit dem sie hereinkam:

$value = self::unwrapNamed( $name, $value );
if ( array_key_exists( $name, $input ) && $input[$name] === $value )
    continue;

Mit der Paarbildung aus Änderung 3 ist dieser Vergleich wieder ein Zeigervergleich für Objekte und geteilte Arrays.

5. Namensauflösungen werden pro Prozess gemerkt

Ein kompiliertes Smarty-Template fragt die Erweiterung jedes Mal nach dem Callback eines Modifiers, wenn es einen verwendet, nicht einmal beim Kompilieren. Auf einer Seite mit Tausenden von Operatoraufrufen lief die Auflösung (ist es ein Hilfsmittel, gibt es einen Operator dieses Namens, gilt exp_) Tausende Male. expSmartyExtension merkt sich jetzt jede Antwort, auch "nicht gefunden":

private static $found = array( 'modifier' => array(), 'function' => array(), 'block' => array() );

public function getModifierCallback( string $modifierName )
{
    if ( !array_key_exists( $modifierName, self::$found['modifier'] ) )
        self::$found['modifier'][$modifierName] = $this->findModifierCallback( $modifierName );
    return self::$found['modifier'][$modifierName];
}

Warum es sicher ist: Welche Operatoren und Funktionen es gibt, ändert sich nicht, während ein Prozess läuft; eine neu aktivierte Erweiterung braucht ohnehin einen Neustart der Worker.

6. Das Zurückschreiben geht über einen Post-Filter

Smarty 5 setzt die Variablen eines Templates zurück, wenn fetch() zurückkehrt, sodass es nach dem Rendern nichts mehr zum Zurückschreiben gab, außer man durchlief das Template, während es lief. Die Brücke fügt jetzt am Ende jedes kompilierten Templates einen Aufruf an, einen Smarty-Post-Filter, der die Variablen des Templates in dem Moment festhält, in dem es endet:

public static function appendCapture( $code )
{
    return $code . "<?php \\expSmartyRenderer::captureVariables( \$_smarty_tpl ); ?>\n";
}

captureVariables() speichert sie unter der ID des Template-Objekts; render() und renderSubtemplate() holen sie nach fetch() heraus und schreiben von dort zurück. Das kostet eine Array-Kopie pro Template, einmal in das Template hineinkompiliert.

7. Nicht gemacht: native Schnellpfade für Operatoren

Eine naheliegende Idee war, den meistgenutzten Operatoren (eq, ne, and, or, concat ...) eine native Smarty-Implementierung zu geben, am Template-System vorbei. Zuerst wurde der Operatoraufruf über die Brücke gemessen: eq, auf einer Seite 1.158-mal aufgerufen, brauchte insgesamt 4,8 ms, etwa 4 Mikrosekunden pro Aufruf. Dort blieb die Zeit nicht, und eine zweite Implementierung jedes Operators müsste das Verhalten des Template-Systems genau treffen (eq vergleicht locker und nimmt mehrere Parameter an; and gibt den letzten wahren Wert zurück, or den ersten). Der Paritätstest (tests/tests/lib/smarty/expSmartyOperatorParityTest.php) garantiert, dass jeder Operatorfall aus den eigenen Tests der Template-Engine in .stpl dieselbe Ausgabe ergibt, weil jeder Operator den eigenen Code des Template-Systems ausführt. Schnellpfade hätten diese Garantie gegen ein paar Millisekunden eingetauscht. Sie wurden nicht gebaut.

Die Reihenfolge der Arbeit

SchrittWas sich änderteWirkung auf die Startseite
Startjede .stpl-Einbindung ein vollständiges Rendern266 Rendervorgänge, 5.483 Operatoraufrufe, wrap() und writeBack() jeder Variablen jedes Mal
1Einbindungen von .stpl als Subtemplates37 Rendervorgänge über die Brücke
2Smarty-Instanz pro Design-Basenkeine Verzeichnisprüfungen und kein Einstellungs-Hash pro Rendern (vorher etwa 1,7 ms pro Aufruf)
3, 4Paarbildung und Überspringen unveränderter Variablendie Umwandlungen und das Zurückschreiben durchlaufen keine unveränderten Werte mehr
5Auflösungen gemerkteine Auflösung pro Name und Prozess
6Erfassung per Post-FilterZurückschreiben, ohne das Template zu durchlaufen
Cachedas ganze Pagelayout in einem {expcacheblock}die meisten Velocity-Anfragen 0,03 bis 0,07 s

Was bei jeder Anfrage weiterhin bezahlt wird

KostenAuf PHP-FPMAuf Velocity
Laden der Smarty-Bibliotheketwa 3 ms pro Anfrageeinmal pro Worker
Anlegen der Smarty-Instanzetwa 2,5 ms pro Anfrageeinmal pro Worker
Die erste Anfrage nach einem kalten Opcode-Cacheetwa 75 mseinmal pro Worker-Start
Jedes über das Template-System gerenderte .stpl (das äußerste, .tpl-Einbindungen von .stpl, name=-Einbindungen)ein Stub-Lauf und ein Renderndasselbe
Jeder Operatoraufrufetwa 4 Mikrosekunden für einen einfachendasselbe
Jede Template-Funktion ({attribute_view_gui} ...)ein Aufruf des Template-Systems über ein erzeugtes .tpldasselbe

Velocity und PHP-FPM

PHP-FPM beginnt jede Anfrage bei null: Der Kernel bootet, die Einstellungen werden gelesen, Smarty wird geladen und seine Instanz angelegt, und der Bootstrap mit dem Debug-Bericht kostet 40 bis 60 ms vor der eigentlichen Seite. Velocity hält seine Worker am Laufen: Der Kernel, die Smarty-Instanz, die kompilierten Templates im Opcode-Cache und die gemerkten Auflösungen bleiben zwischen Anfragen im Speicher. Deshalb erreicht eine .stpl-Seite auf Velocity 0,04 s oder weniger und bleibt auf PHP-FPM mit eingeschaltetem Debug-Bericht bei 0,08 bis 0,10 s.

Ein Worker behält von den Variablen einer Anfrage nichts für die nächste: Die Paare aus Änderung 3 und die erfassten Variablen aus Änderung 6 werden verworfen, wenn das äußerste Rendern einer Anfrage endet. Ein Test, der dieselbe Seite 25-mal mit einer Cookie-Datei auf Velocity neu lud, zeigte keine Verlangsamung von einer Anfrage zur nächsten.

Was ein dauerhafter Worker behält und was Sie wissen müssen:

  • die Smarty-Instanz und die Einstellungen, aus denen sie gebaut wurde: Nach einer Änderung von smarty.ini starten Sie die Worker neu (./console exp:velocity deploy --allow-root-user erledigt das);
  • die gemerkten Namen: Ein Operator oder eine Funktion, die später verfügbar wird, ist nach einem Neustart bekannt;
  • der Eingabemodus jedes Operators und ParameterOperatorList[]: einmal pro Prozess gelesen.

Die Caches, und was jeder hier bewirkte

EbeneGleich für .tpl und .stpl?Was wir gelernt haben
Ganzseiten-Cache (rollenbewusster HTTP-Cache, httpcache.ini)ja, er hält Ausgabespeichert nie eine Seite, die einen Debug-Bericht trägt; eine Seite, die ein anderer Besucher in den Cache gebracht hat, zeigt HIT
Antwort-Cache von Velocityjaantwortet, bevor ein Worker gewählt wird
Content-View-Cacheja0 SQL-Abfragen bei einer wiederholten Vollansicht in beiden Engines
{expcacheblock}derselbe Cache wie {cache-block}braucht [TemplateSettings] TemplateCache=enabled; ein Block um das ganze Pagelayout brachte am meisten
Kompilierte Stubs und Smartys kompilierte Templatesnur .stpleinmal geschrieben; CompileCheck entscheidet, ob eine Änderung bemerkt wird

Der Ganzseiten-Cache und der Debug-Bericht

Der Ganzseiten-Cache (der rollenbewusste HTTP-Cache, für die Siteaccesses in [HttpCacheSettings] CachedSiteAccesses[] von httpcache.ini eingeschaltet) hält ganze Seiten für anonyme Besucher. Er speichert nie eine Antwort, die den Debug-Bericht trägt (die Exp-Debug-Leiste oder den klassischen Bericht), und sagt das auch:

curl -s -o /dev/null -D - https://www.example.com/fitness | grep -i x-exp-cache
x-exp-cache: BYPASS (debug report)

Zwei Folgen für das Messen:

  • Mit eingeschalteter Debug-Leiste sehen Sie immer ein Rendern, nie den Cache. Das ist, was Sie wollen, wenn Sie Templates messen.
  • Ohne sie zeigt eine Seite, deren Speicherung ein anderer Besucher schon ausgelöst hat, x-exp-cache: HIT, und ihre Zeit sagt nichts über Templates. So kam es, dass die .tpl-Startseite oben keine Skriptzeit zum Vergleich hatte: Sie kam aus dem Cache.

Der Content-View-Cache

Eine Vollansicht wird als Ausgabe pro Knoten, Ansicht, View-Parametern, Sprache sowie den Rollen und Beschränkungen des Besuchers gehalten. Er arbeitet für beide Engines gleich: Eine wiederholte Vollansicht führte in keiner der beiden eine einzige SQL-Abfrage aus. Das Pagelayout drumherum gehört nicht zum View-Cache; es wird bei jeder Anfrage gerendert, sofern es kein Cache-Block hält.

{expcacheblock} braucht TemplateCache

{expcacheblock} speichert nur mit [TemplateSettings] TemplateCache=enabled in den Template-Block-Cache; ist es aus, läuft der Rumpf des Blocks bei jeder Anfrage, und nichts wird gespeichert, ohne jede Meldung. Prüfen Sie das zuerst, wenn ein Block nicht zu cachen scheint.

Die Seite in einem Cache-Block

Das Pagelayout ist der Teil jeder Seite, den der View-Cache nicht hält: der Kopf, die Menüs, die Layout-Zonen von Exponential Layouts, der Fuß. Die Media-Portierung hält all das in einem {expcacheblock}. Die erste Version hatte drei Blöcke (Kopf, Layout, Seitenende); sie zu einem zusammenzulegen, brachte die Velocity-Zahlen auf 0,03 bis 0,07 s herunter, weil eine gecachte Anfrage dann fast nichts vom Pagelayout ausführt.

Die Schlüssel des Blocks, aus templates/pagelayout.stpl:

{$el_page_user = fetch('user', 'current_user')}
{expsetblock variable='exp_dynamic_parts' scope='global'}
1{/expsetblock}
{capture assign=el_page_html}
{expcacheblock id=4 keys=(['pagelayout-page', $module_result.content_info.node_id|default:0, $module_result.uri|default:'', $module_result.content|md5, $el_page_user.role_id_list|exp_implode:',', $el_page_user.limited_assignment_value_list|exp_implode:',', $el_page_user.is_logged_in])}
... the whole page ...
{/expcacheblock}
{/capture}
SchlüsselWarum
'pagelayout-page'ein Name, damit der Schlüssel nie auf den eines anderen Blocks trifft
$module_result.content_info.node_idder angezeigte Knoten
$module_result.uriSeiten ohne Knoten (Suche, Benutzerseiten, Fehlerseiten)
$module_result.content|md5alles, was die Ansicht erzeugt hat: Blättern, Suchergebnisse, Formularfehler ergeben eine andere Seite
$el_page_user.role_id_listwas der Besucher sehen darf, hängt von seinen Rollen ab
$el_page_user.limited_assignment_value_listRollen, die auf einen Teilbaum oder eine Sektion beschränkt sind
$el_page_user.is_logged_inanonyme und angemeldete Seiten unterscheiden sich auch bei denselben Rollen
der Siteaccessvom Block selbst hinzugefügt

Der Teil pro Besucher als Platzhalter

Das Benutzermenü mit dem Namen des Besuchers und der Anzahl im Warenkorb gehört dem Besucher allein und darf nie gespeichert werden. Während der Seitenblock gebaut wird, sagt ein globales Flag das, und der Kopfbereich schreibt eine Markierung statt des Menüs. templates/pagelayout/header.stpl:

{if and(is_set(expvar('exp_dynamic_parts', '')), eq(expvar('exp_dynamic_parts', ''), '1'))}
<!--exp-dynamic:user_menu-->{else}
{expinclude uri='design:pagelayout/header/user_menu.tpl'}{/if}

Nach dem Block, ob gecacht oder frisch gerendert, löscht das Pagelayout das Flag, rendert das Menü und setzt es an die Stelle der Markierung:

{expsetblock variable='exp_dynamic_parts' scope='global'}
0{/expsetblock}
{capture assign=el_user_menu}
{expinclude uri='design:pagelayout/header/user_menu.tpl'}{/capture}
{($el_page_html|exp_explode:'<!--exp-dynamic:user_menu-->')|exp_implode:$el_user_menu}{$el_page_html = null}

Das Flag ist global ({expsetblock ... scope='global'}, gelesen mit expvar(..., '')), weil der Kopfbereich mehrere Einbindungsebenen tiefer liegt; die Markierung ist ein HTML-Kommentar, harmlos, falls sie je ausgegeben wird. Das .tpl-Pagelayout des Media-Designs cacht sein Layout auf dieselbe Weise ({set-block scope=global variable=exp_dynamic_parts}, {cache-block keys=...}, {$el_layout_html|explode( '<!--exp-dynamic:user_menu-->' )|implode( $el_user_menu )}), sodass beide Engines Gleiches mit Gleichem cachen.

Die Teile pro Besucher finden: eine durchgearbeitete Bestandsaufnahme

Bevor Sie eine ganze Seite cachen, muss jeder Teil gefunden werden, der vom Besucher abhängt. Die Bestandsaufnahme des Media-Designs:

TeilHängt ab vonWie er behandelt wurde
Benutzermenü mit der Anzahl im Warenkorb (pagelayout/header/user_menu)der Sitzung, dem Warenkorbder Platzhalter oben: bei jeder Anfrage frisch gerendert
Die Merkzettel-Schaltfläche (content/parts/product_buy_form.stpl)is_logged_inabgedeckt durch den Schlüssel is_logged_in
Der Titel einer Fehlerseite (pagelayout/head/title.stpl: "Please sign in to see this page" oder "You don't have access to this page" bei einem Zugriffsfehler)is_logged_inabgedeckt durch den Schlüssel is_logged_in
Menüs und Listen, die ausblenden, was der Besucher nicht lesen darfRollen und Beschränkungenabgedeckt durch role_id_list und limited_assignment_value_list
Formulare mit einem Formular-Tokender Sitzungnichts zu tun: Das Token wird nach dem Rendern zur Ausgabe hinzugefügt

So finden Sie sie in Ihrem Design: Durchsuchen Sie die Templates nach current_user, is_logged_in, basket, session, ezhttp, ezpreference, csp_nonce und nach Fetches der Daten des aktuellen Benutzers; öffnen Sie jede Seite angemeldet und abgemeldet und vergleichen Sie.

Was außerhalb eines gecachten Blocks bleiben muss

  • Inhalt pro Besucher: der aktuelle Benutzer, die Sitzung, der Warenkorb, Meldungen. Verwenden Sie einen Platzhalter.
  • Skripte und Stile, die beim Rendern angefordert werden: ezscript_require() und ezcss_require() registrieren eine Datei für den Kopf oder das Ende der Seite, wenn sie laufen. In einem gecachten Block laufen sie bei einer gecachten Anfrage nicht, und die Datei fehlt auf der Seite. Fordern Sie sie außerhalb des Blocks an, oder halten Sie den Code, der sie ausgibt, im selben Block.
  • csp_nonce(): Es ändert sich bei jeder Anfrage; eine gespeicherte Nonce passt nicht mehr zum Header der Seite, und der Browser blockiert das Skript.
  • Kein Problem: Formulare. Das Formular-Token angemeldeter Besucher (ezformtoken) wird jedem <form method="post"> in der Ausgabe hinzugefügt, nachdem alle Templates gelaufen sind, sodass ein Formular, das aus einem Cache-Block kommt, das aktuelle Token bekommt.

Was den Block verfallen lässt

EreignisWirkung
Eine Inhaltsveröffentlichunglässt jeden Template-Block-Cache verfallen, sodass die nächste Anfrage die Seite neu rendert
Eine Layout-Veröffentlichung oder eine Änderung einer Layout-Regel (Exponential Layouts)lässt ebenfalls jeden Template-Block-Cache verfallen: explayouts_core ruft eZContentObject::expireTemplateBlockCache() auf, weil ein Pagelayout das gerenderte Layout in einem Block hält
expiry des Blockssein Alter (der Standard ist zwei Stunden)
php bin/php/ezcache.php --clear-tag=templatealles, was mit Templates zu tun hat, die Blöcke eingeschlossen

Wie man misst

Die Debug-Leiste

Schalten Sie die Debug-Ausgabe für Ihre eigene Adresse ein (die Exp-Debug-Leiste). Die Seite wird dann immer gerendert (der Ganzseiten-Cache lässt sie durch), und die Leiste zeigt:

WoWas zu lesen ist
Die Leistedie Skriptzeit, die Anzahl der SQL-Abfragen, den Spitzenspeicher
Reiter Timing, ZeitakkumulatorenTemplate processing (die Arbeit der Templates), Template load, Load cache, Cache load, TS init (das Übersetzungssystem)
Reiter Rendering, Content-View-CacheTreffer oder erzeugt, und warum
Reiter Rendering, Cache-Blöckejedes {cache-block} und {expcacheblock} (benannt nach seiner .stpl-Datei und id), Treffer oder erzeugt, mit seiner Zeit
Reiter Rendering, Template-Baumjedes Template mit seiner Zeit, .stpl-Subtemplates unter dem Template, das sie eingebunden hat

Vergleichen Sie Engines mit demselben Debug-Zustand: Der Debug-Bericht selbst kostet Zeit, eine Seite mit der Leiste gegen eine Seite ohne sie ist also kein Vergleich.

curl

Ohne Debug-Ausgabe, aus einer Shell, der Median von zehn Anfragen:

for i in 1 2 3 4 5 6 7 8 9 10; do
    curl -s -o /dev/null -w '%{time_total}\n' https://www.example.com/smarty/fitness
done | sort -n | sed -n 5,6p

Prüfen Sie gleichzeitig x-exp-cache: Ein HIT misst den Ganzseiten-Cache, nicht die Templates.

Regeln, die die Zahlen ehrlich hielten

  • Mehrere Anfragen, der Median. Einzelne Anfragen schwanken stark; zehn Anfragen und der mittlere Wert sind stabil.
  • Identische Bedingungen. Dieselben Caches warm (der View-Cache, der Block-Cache), derselbe Debug-Zustand, derselbe Server, direkt nacheinander.
  • Achten Sie auf die Last des Servers. Die Ergebnisse schwankten mit der Last um das Drei- bis Fünffache. Während eines Laufs lag die Last bei 52 auf 12 Kernen, und jede Zahl dieses Laufs war bedeutungslos; er wurde verworfen und später neu gemessen.
  • Prüfen Sie auf Anhäufung in dauerhaften Workern. Laden Sie dieselbe Seite viele Male mit einer Cookie-Datei neu (curl -b var/tmp/jar -c var/tmp/jar ... 25-mal) und achten Sie auf einen Trend. Es gab keinen.
  • Wissen Sie, was geantwortet hat. Ein Treffer im Ganzseiten-Cache, ein Treffer im View-Cache und ein Rendern sind drei verschiedene Messungen.

Einstellungen, auf die es ankommt

EinstellungStandardWirkung auf die Geschwindigkeit
[SmartySettings] CompileCheck (smarty.ini)enabledenabled: Smarty prüft jedes .stpl bei jeder Verwendung auf eine Änderung. disabled spart diese Prüfungen im Produktivbetrieb; leeren Sie dann die Template-Caches nach jeder Template-Änderung und starten Sie die Worker neu, da die Instanz (mit der Einstellung) gemerkt wird
[SmartySettings] Debuggingdisabledenabled fügt jeder Seite Smartys Debug-Konsole hinzu; nie im Produktivbetrieb
[SmartySettings] Securitydisabledenabled kompiliert Templates mit der Sicherheitsrichtlinie nach <cache dir>/smarty/compile-secure. Die Prüfung erfolgt beim Kompilieren eines Templates, nicht beim Ausführen, ein kompiliertes Template kostet also dasselbe; das Einschalten kompiliert jedes Template einmal neu
[SmartySettings] ParameterOperatorList[]leerOperatoren ohne Template-Hinweise, die nur ihre Parameter lesen; einmal pro Prozess gelesen. Keine Geschwindigkeitseinstellung, aber ein falscher Modus bedeutet falsche Ausgabe
[TemplateSettings] TemplateCache (site.ini)enabledohne sie cacht {expcacheblock} nichts
[ContentSettings] ViewCachingenabledder Content-View-Cache, für beide Engines
[HttpCacheSettings] Enabled, CachedSiteAccesses[] (httpcache.ini)disabledder Ganzseiten-Cache für anonyme Besucher

Checkliste für eine schnelle .stpl-Website

  1. Liefern Sie sie mit Velocity aus, wenn Sie können; auf PHP-FPM stellen Sie sicher, dass der Opcode-Cache an und warm ist.
  2. Binden Sie .stpl aus .stpl mit {expinclude uri=...} ohne name= ein, damit es als Subtemplate läuft.
  3. Halten Sie das Pagelayout in einem {expcacheblock} mit Schlüsseln aus dem Knoten, der URI, dem md5 des Inhalts und den Rollen, Beschränkungen und dem Anmeldezustand des Besuchers, mit den Teilen pro Besucher als Platzhaltern.
  4. Machen Sie eine Bestandsaufnahme der Teile pro Besucher, bevor Sie cachen, und testen Sie angemeldet und abgemeldet.
  5. Halten Sie ezscript_require(), ezcss_require() und csp_nonce() aus gecachten Blöcken heraus.
  6. Setzen Sie {expcacheblock} um teure Fetches in Ansichten, die der View-Cache nicht hält.
  7. Prüfen Sie [TemplateSettings] TemplateCache=enabled und den View-Cache.
  8. Erwägen Sie im Produktivbetrieb CompileCheck=disabled, mit einem Leeren des Template-Caches und einem Neustart der Worker in jedem Deploy.
  9. Messen Sie mit der Debug-Leiste und mit curl, Mediane von zehn, identische Bedingungen, und achten Sie auf x-exp-cache.

Fallstricke

FallstrickWas passiertStattdessen
{expinclude ... name='x'} für ein .stpl, das keinen Namensraum brauchtes geht durch das Template-System: ein Stub und ein vollständiges Rendernname= weglassen
Ein Cache-Block ohne die Rollen des Besuchers in seinen Schlüsselnein Besucher sieht ein Menü oder eine Liste, die für jemand anderen gemacht wurderole_id_list, limited_assignment_value_list, is_logged_in in die Schlüssel aufnehmen
Inhalt pro Besucher in einem Cache-Blockder Name oder Warenkorb des ersten Besuchers wird allen gezeigtein Platzhalter, der nach dem Block gerendert wird
ezscript_require() in einem Cache-Blockdas Skript fehlt bei gecachten Anfragenes außerhalb des Blocks anfordern
TemplateCache ausgeschaltetBlöcke cachen nichts, stillschweigendeinschalten
Messen mit eingeschalteter Debug-Leiste bei einer Engine und ausgeschalteter bei der anderendie 40 bis 60 ms des Debug-Berichts entscheiden den Vergleichderselbe Debug-Zustand für beide
Messen eines Treffers im Ganzseiten-Cachedie Zeit sagt nichts über Templatesx-exp-cache prüfen; die Debug-Leiste verwenden
Messen auf einem ausgelasteten Serverdie Zahlen schwanken um das Drei- bis Fünffachemessen, wenn die Last niedrig ist, und wiederholen
smarty.ini ändern und erwarten, dass es sofort wirktdie Instanz und die Auflösungen werden pro Worker gemerktdeployen (die Worker neu starten)
CompileCheck=disabled ohne Leeren des Caches im Deployalte Templates laufen weiterdie Template-Caches in jedem Deploy leeren
Smartys eigenes count, implode, explode bei Änderungen von Handfalsche Ausgabe, nicht langsamerdie exp_-Namen

Verwandte Seiten

Werden Sie Exponential-Partner

Partner teilen ihre Informationen, stellen Mittel bereit, geben Beiträge zurück und entwickeln die Produkte mit uns, und so wächst Exponential. Eine Partner-Website und ein Dashboard sind für Mitte 2027 geplant: Werden Sie noch heute Partner, damit wir schneller wachsen und neue Funktionen früher liefern.

Something wrong on this page? Report an error

Documentation license

This documentation is free documentation, licensed under the GNU Free Documentation License 1.3 or later.

Exponential Copyright © 1998-2026 Exponential Foundation and 7x