Laravel Homestead Performance mit NFS verbessern (NFS aktivieren)

Wer viel mit Laravel Homestead arbeitet wird hier und da mit Performance Problemen zu kämpfen haben. Alleine die Erhöhung der zugewiesenen CPU-Kerne und des RAMs in der Homestead.yaml reichen da nicht aus. Besonders langsam ist die Dateien-Synchronisation. Vor allem in der Frontend-Entwicklung, wo Live-Synchronisation eine große Rolle spielt, ist es wichtig, dass Dateiänderungen sofort übernommen werden.

Das Problem liegt bei VirtualBox und ihrem langsamen “shared folder system”. Die Lösung heißt “Network File System” (NFS), ein Protokoll für verteilte Dateisysteme und ist schnell zu installieren.
Vagrant bietet hier eine gute Dokumentation zu NFS, welches bei heutigen Betriebsystemen leider nicht out-of-the-box zur Verfügung steht.
Die Installation gestaltet sich in drei einfachen Schritten.

1) Installiert den NFS-Kernel

Unter Linux/MacOS steht es jedem zur Verfügung. Wer mit Windows unterwegs ist sollte sich WinNFSd  (von vagrant bereitgestellt) anschauen.

Loggt euch hierfür über vagrant ssh in Laravel Homestead ein. Dort führt ihr folgenden Befehl aus:

sudo apt-get install nfs-kernel-server

2) Passt eure Homestead.yaml an

Die Homestead.yaml findet ihr in der Regel unter ~/.homestead/Homestead.yaml
Hierfür müsst ihr euren zu synchronisierenden Ordnern den Typ “nfs” zuweisen:

folders:
- map: ~/Code/folders2sync
  to: /home/vagrant/projects
  type: "nfs"

3) Vagrant mit – – provision neustarten

Falls Homestead noch läuft: Verlasst Homestead mit exit und haltet die VM danach mit vagrant halt an.

Im Anschluss:

vagrant up --provision

Bei der Entwicklung von stomt konnten wir dadurch die gulp-task Ausführungen bei Script-Veränderungen von 1 Minute auf 3 Sekunden herunterschrauben.

Der Grund warum NFS nicht von vorne herein aktiviert ist liegt darin, dass NFS bei den Betriebsystemen nicht von Haus aus unterstützt wird und der hier genannte Schritt 1) notwendig ist.

Der Artikel ist angelehnt an den Beitrag in osteels Blog.

Ein Überblick über PHP Compiler und ihre Ausgaben von Nicolas Favre-Felix

Quelle: A review of PHP compilers and their outputs – By Nicolas Favre-Felix

Ein klasse Beitrag. Hier die Übersetzung:

Einleitung

Facebook generierte ganz schön viel Begeisterung als sie vor ein paar Wochen das Release ihres neuen PHP-Compilers ankündigten, HipHop-PHP. In diesem Artikel, werden wir bestehende PHP Optimierungs-Tools und was sie können um die Geschwindigkeit von PHP Seiten zu erhöhen besprechen. Das Release erhitzte erneut die Debatte darüber, ob Web-Applikationen durch die Geschwindigkeit von PHP oder durch die Geschwindigkeit ihrer Datenbank begrenzt sind; dieser Artikel handelt nur von Optimierungs-Werkzeugen für PHP Code.

Wir werden die folgenden Konzepte diskutieren:


Die Zend Engine, PHP opcodes

Die Zend Engine ist eine virtuelle Machine welche PHP Skripte ausführt. Es ist die offizielle Implementierung der PHP-Sprache. Diese virtuelle Maschine basiert auf Opcode: PHP Skripte sind in eine einfachere Sprache kompiliert, welche eine limitierte Anzahl von Operationen unterstützt. Zum Beispiel: Werte hinzufügen, eine Funktion aufrufen, Variablen vergleichen mit == sind sollche Operationen; ihre Opcodes sind ADD, DO_FCALL_BY_NAME, IS_EQUAL.

Wenn PHP-Skripte ausgeführt werden, passiert folgendes:

  1. Das Skript wird gelesen und in Tokens geteilt, welche in einen Parser gespeist werden
  2. Wenn das Skript valides PHP ist, wird Opcode generiert
  3. Die Zend Enginge führt den Opcode aus, indem es eine Funktion für jeden Opcode ausführt

Für eine detailliertere Erklärung dieses Prozesses, schaut rüber zu Sara Golemon’s Blog Post zum Verstehen von Opcode(Englisch).

Lasst uns den generierten Opcode anhand eines Beispiels untersuchen:

function fib($n) {

if($n === 0 || $n === 1) {
return $n;
}
return fib($n-1) + fib($n-2);
}

echo fib(30)."\n";

Dieses kleine Skript wird durch diesen ganzen Artikel hindurch verwendet, um den Wandel mit den verschiedenen Kompilierungs-Werkzeugen zu untersuchen.

Die Zend Engine generiert zwei Code-Blöcke: Einen für die fib Funktion und einen für den Top-Level-Call. Ich benutze die Vulcan Logic Dumper Erweiterung um den Opcode auszugeben, indem ich folgenden Befehl nutze: php -d vld.active=1 -d vld.execute=0 -f test.php

function name:  fib
number of ops: 20
compiled vars: !0 = $n
line # op fetch ext return operands
-------------------------------------------------------------------------------
29 0 RECV 1
31 1 IS_IDENTICAL ~0 !0, 0
2 JMPNZ_EX ~0 ~0, ->5
3 IS_IDENTICAL ~1 !0, 1
4 BOOL ~0 ~1
5 JMPZ ~0, ->8
32 6 RETURN !0
33 7* JMP ->8
34 8 INIT_FCALL_BY_NAME 'fib'
9 SUB ~2 !0, 1
10 SEND_VAL ~2
11 DO_FCALL_BY_NAME 1
12 INIT_FCALL_BY_NAME 'fib'
13 SUB ~4 !0, 2
14 SEND_VAL ~4
15 DO_FCALL_BY_NAME 1
16 ADD ~6 $3, $5
17 RETURN ~6
35 18* RETURN null
19* ZEND_HANDLE_EXCEPTION

function name:  (null)
number of ops: 7
compiled vars: none
line # op fetch ext return operands
-------------------------------------------------------------------------------
29 0 NOP
37 1 SEND_VAL 30
2 DO_FCALL 1 'fib'
3 CONCAT ~1 $0, '%0A'
4 ECHO ~1
40 5 RETURN 1
6* ZEND_HANDLE_EXCEPTION

Das sollte für jeden lesbar sein, der jemals Assembler-Sprache genutzt hat mit Registers und einem Stack. Ich bin jedoch verwundert über den/das NOP.


Opcode Cache

Jede HTTP-Anfrage liest und kompiliert die Datei erneut, bevor der Opcode ausgeführt wird. Für den Großteil der PHP Seiten, verbraucht das den verhältnismässig größten Anteil der gesamten Ausführungszeit, Opcode zu generieren, egal ob der Quellcode sich verändert hat oder nicht. Opcode Caches sind Plugins für die Zend Engine welche eine Kopie für den generierten Opcode nachdem er zum ersten mal gelesen wurde behält und umgeht dadurch das Parsing und Generieren bei den nächsten malen. Sie überprüfen lediglich ob sich die Datei seit dem letzten mal verändert hat und natürlich ist es ebenfalls möglich, diese Überprüfung auszustellen, um noch mehr Performance zu erreichen.

Die häufigsten Opcode Caches sind APC, XCache, eAccelerator. Eine volle Liste und Geschichte ist auf Wikipedia vorhanden. APC hat Beiträge von Facebook bekommen, wo es genutzt wurde. Facebook Entwickler haben ausserdem auf Webkonferenzen über APC tuning gesprochen.

Opcode Caches sind einfach zu nutzen und bringen oftmals “kostenlose” Performance ohne irgendeinen Code optimieren zu müssen.


PHP Erweiterungen: Wenn Opcodes Caching nicht genug ist

Falls ihr wirklich sicher seid, das der Flaschenhals die Ausführung des PHP Codes ist, gibt es einen Weg die Geschwindigkeit zu steigern, indem ihr manche Teile des PHP Codes in C umgeschreibt. Dieser C Code ist in eine .so Datei kompiliert, welche vom PHP Interpreter zur Laufzeit geladen wird; die kompilierten Module exportieren Funktionen und Klassen so, das PHP Skripte sie direkt nutzen können. Wann immer ihr einen Aufruf zum Memcache von PHP macht, benutzt ihr eine Erweiterung welche in C geschrieben ist.

Erweiterungen werden innerhalb PHP geladen und nutzen die internen Datenstrukturen und Schnittstellen(APIs) der Zend Engine. PHP Erweiterungen zu schreiben ist lästig: Es gibt nicht viele Dokumentationen, viele Funktionen sind Makros, sind inkonsistent oder verwirrend… Man macht eine schlechte Erfahrung damit…

Die Performance ist meistens von der Applikation abhängig
. Ich habe einen 60 fachen Geschwindigkeits-Zuschub bei bestimmten Funktionen: Die Möglichkeit zu haben Zeiger und benutzerdefinierte Datenstrukturen in C zu nutzen ist wesentlich effizienter als jedes mal den kompletten Code kopieren zu müssen, jedes mal wenn sich eine Variable ändert.

Das heißt, ihr könnt nicht einfach neuschreiben und erwarten das eure Funktionen besser laufen; Mögliche Flaschenhälse zu identifizieren und ein paar Kernfunktionen neu zu schreiben hilft aber dennoch.

PHP Erweiterungen mit PHC generieren
PHC ist ein PHP Compiler welcher von Paul Biggar geschrieben wurde, als Teil seines PhD. Es kann bestehenden PHP Code in C konvertieren, um als Erweiterung für PHP kompiliert zu sein. Die Idee ist, weiterhin dieselben Klassen und Funktionen aufzurufen, nur das sie dann schneller sein werden, weil sie in C geschrieben sind.

Es ist oft schwer dem Code den PHC generiert zu folgen und es gibt keinen einfachen Weg um es als C-Basis zu nutzen und ihn von Menschenhand zu warten.

Unsere fib Funktion hat eine 2500-Zeilen lange Datei generiert, die ersten 1350 sind PHC
Standardformulierungen welche vom Rest genutzt werden.

Eine generierte Kommentierung in der Ausgabe erklärt wie PHC den Code transformiert hat:

function fib($n)
{
$TLE2 = 0;
$TLE0 = ($n === $TLE2);
if (TLE0) goto L16 else goto L17;
L16:
$TEF1 = $TLE0;
goto L18;
L17:
$TLE3 = 1;
$TEF1 = ($n === $TLE3);
goto L18;
L18:
$TLE4 = (bool) $TEF1;
if (TLE4) goto L19 else goto L20;
L19:
return $n;
goto L21;
L20:
goto L21;
L21:
$TLE5 = 1;
$TLE6 = ($n - $TLE5);
$TLE7 = fib($TLE6);
$TLE8 = 2;
$TLE9 = ($n - $TLE8);
$TLE10 = fib($TLE9);
$TLE11 = ($TLE7 + $TLE10);
return $TLE11;
}

Hier ist ein Auszug aus dem generierten C-Code, entsprechend zu dem Kommentar weiter oben: (Ich habe die wichtigsten Punkte hervorgehoben; der Rest sind Standardformulierungen)

// $TLE11 = ($TLE7 + $TLE10);
{
if (local_TLE11 == NULL)
{
local_TLE11 = EG (uninitialized_zval_ptr);
local_TLE11->refcount++;
}
zval** p_lhs = &local;_TLE11;
zval* left;
if (local_TLE7 == NULL)
{
left = EG (uninitialized_zval_ptr);
}
else
{
left = local_TLE7;
}
zval* right;
if (local_TLE10 == NULL)
{
right = EG (uninitialized_zval_ptr);
}
else
{
right = local_TLE10;
}
if (in_copy_on_write (*p_lhs))
{
zval_ptr_dtor (p_lhs);
ALLOC_INIT_ZVAL (*p_lhs);
}
zval old = **p_lhs;
int result_is_operand = (*p_lhs == left || *p_lhs == right);
add_function(*p_lhs, left, right TSRMLS_CC);
if (!result_is_operand)
zval_dtor (&old;);
phc_check_invariants (TSRMLS_C);
}

Achtet auf den komischen Weg derAusführung, wahrscheinlich durch die fehlende Typen-Interference: Der PHC Compiler hat sein bestes gegeben um alle möglichen Aspekte abzudecken und das braucht Zeit.


Wie PHC den PHP’s “embed” Modus nutzt um ausführbare Dateien zu generieren

PHP hat verschiedene Interfaces, welche SAPIs (Server API) genannt werden. Existierende SAPIs enthalten apache, cli, cgi-fgci… Eine von ihnen unterstützt einen Weg um PHP Parser und virtuelle Maschine in C Programme einzubetten. PHC hat einen Vorteil von diesem Feature um die PHP Laufzeit zu bündeln zusammen mit dem generierten C-Code, während es eine ausführbare Binärdatei produziert.

Andere Compiler

Es gibt noch zwei andere Compiler, Roadsend-PHP und HipHop-PHP. Roadsend wurde neugeschrieben um LLVM zu nutzen, aber das Projekt ist anscheinend immernoch im Kindesalter, da die neue Version noch nicht implementiert ist. Diese Compiler sind anders als PHC, da sie nicht die Zend Laufzeit aber stattdessen ihr eigenes Ausführungs-System nutzen; beide sind fähig ausführbaren Dateien zu generieren.

Ein Blick auf Roadsend’s Ausgabe

Roadsend-PHP transformiert PHP Code in Scheme, eine funktionelle Sprache. Der Scheme Code ist dann in C konvertiert und kompiliert um eine ausführbare Binärdatei zu produzieren.

Hier ist die Ausgabe für fib:

(define test:test.php/fib
(lambda ($n)
#f
(push-stack 'unset 'fib $n)
(set! *PHP-LINE* 2)
(set! *PHP-FILE* "test.php")
(let ((ret1112
(begin
(begin0
(bind-exit
(return)
(let ()
#t
(begin
(if (or (identicalp $n #e0) (identicalp $n #e1))
(begin (return (copy-php-data $n)))
(begin))
(return
(php-+ (maybe-unbox
(begin
(set! *PHP-FILE* "test.php")
(set! *PHP-LINE* 7)
(let ((retval1110
(test:test.php/fib (php-- $n #e1))))
(set! *PHP-FILE* "test.php")
(set! *PHP-LINE* 7)
retval1110)))
(maybe-unbox
(begin
(set! *PHP-FILE* "test.php")
(set! *PHP-LINE* 7)
(let ((retval1111
(test:test.php/fib (php-- $n #e2))))
(set! *PHP-FILE* "test.php")
(set! *PHP-LINE* 7)
retval1111))))))
NULL))))))
(pop-stack)
ret1112)))

Ich habe den folgenden Befehl genutzt: pcc -v test.php -O --no-clean.

*PHP-FILE* und *PHP-LINE* sind globale Variablen welche aktualisiert werden, wenn der Code ausgeführt wird. Abgesehen von ein paar PHP-ähnlichen Funktionsaufrufen, ist der Code nach Scheme mit speziellen Operatoren für PHP Variablen aufgebaut. Das heißt, der generierte C-Code ist absolut unlesbar.
Zum Vergleich: auf meiner Maschine, fib(30) aufzurufen in PHP benötigt 0.95 Sekunden, während die von Roadsend generierte Binärdatei 0.44 Sekunden braucht. N.B. ist kein angemessener Vergleich.


Ein Blick auf HipHop’s Ausgabe

HipHop produziert folgende Ausgabe:

Variant f_fib(Numeric v_n) {
FUNCTION_INJECTION(fib);
if (same(v_n, 0LL) || same(v_n, 1LL)) {
return v_n;
}
return plus_rev(LINE(7,f_fib(v_n - 2LL)), f_fib(v_n - 1LL));
} /* function */

Das ist eine echte C++ Funktion welche ziemlich vergleichbar mit ihrem PHP Code ist.
Sie wird durch folgende Zeile aufgerufen:

echo(concat(toString(LINE(10,f_fib(30LL))), "\n"));

Das ist allerdings einfach zu hacken und einfach nicht verständlich.
Dieser Code lief auf meiner Maschine in der selben Zeit, wie der von Roadsends Compiler genierierte.
Das ist trotzdem kein fairer Vergleich, da das Programm in den Webserver eingebettet ist: Ein bedeutender Teil dieser Ausführung geht für das Setup und die Initialisierung drauf.


Fazit

Webentwickler haben viele Möglichkeiten wenn es Zeit ist, existierenden PHP-Code zu optimieren. Es gibt keinen Königsweg und der erste Schritt sollte immer sein, besseren Code zu schreiben; ein optimierender Compiler sichert nicht dein Blubble Sort-Verfahren. Die Big-O Notation zu nutzen ist ein guter Anfang, vereinfachte Daten-Strukturen anstatt von komplexen Hierachien von Objekten zu verwenden hilft oftmals auch gut.Wenn dein Code sauber ist, versuche Schritt für Schritt zu optimieren, ebenso wie deine Nutzerzahl wächst: Erst mit einem Opcode Cache und dann nutze einen Compiler erst, wenn du ihn wirklich brauchst. Chancen sind vorhanden, ein gut getunter APC wird schnell genug sein und es wird dir möglich sein, Dinge schnell ändern zu können, ohne die ganze Code-Basis neu kompilieren zu müssen.

Hinweise zu HipHop-PHP: Dieses Projekt sieht sehr vielversprechend aus aber ist noch sehr jung zur Zeit und trotzdem wird es von Facebook genutzt. Ich würde nicht empfehlen alles darauf laufen zu lassen bevor die Ecken und Kanten nicht weg sind.
Vergleichbare Bench
marks erscheinen bald in Foren und Blogs: Wenn du dich wirklich für eine technische Entscheidung auf sie verlässt, gehe sicher, dass sie die selben Dinge vergleichen. HipHop-PHP hat zum Beispiel seinen eigenen Webserver, und das hat Einfluss auf jeden HTTP-Benchmark. HTTP Benchmark: Vergleiche nicht Apache und libevent wenn du versuchst APC gegen HipHop zu vergleichen.

############

Ich finde diesen Beitrag echt klasse. Ich hoffe die Übersetzung ist nicht zu holprig, mir hat es leider ein wenig an Zeit gefehlt. Ich werde sie vielleicht bei Zeiten noch einmal überarbeiten.
Natürlich habe ich die schriftliche Erlaubnis den Text zu übersetzen und hier zu posten!

Übersetzt von Philipp Zentner.