hiphop compiler for php

Facebook 2010 (confidential)

HipHop Compiler for PHP

Transforming PHP into C++

HipHop Compiler TeamFacebook, Inc.

May 2010

PHP is easy to read


<?php

function tally($count) { $sum = 0; for ($i = 0; $i < $count; ++$i) { $sum += $i; } return $sum;}

print tally(10) . “\n”;

PHP syntax is similar to C++/Java


<?php

class Tool extends Object { public $name;

public use($target) {}}

$tool = new Tool();$tool->name = ‘hammer’;$tool->use($nail);

PHP Statements and Expressions


ExpressionList, AssignmentExpression, SimpleVariable, DynamicVariable, StaticMemberExpression, ArrayElementExpression, DynamicFunctionCall, SimpleFunctionCall, ScalarExpression, ObjectPropertyExpression, ObjectMethodExpression, ListAssignment, NewObjectExpression, UnaryOpExpression, IncludeExpression, BinaryOpExpression, QOpExpression, ArrayPairExpression, ClassConstantExpression, ParameterExpression, ModifierExpression, ConstantExpression, EncapsListExpression,

FunctionStatement, ClassStatement, InterfaceStatement, ClassVariable, ClassConstant, MethodStatement, StatementList, BlockStatement, IfBranchStatement, IfStatement, WhileStatement, DoStatement, ForStatement, SwitchStatement, CaseStatement, BreakStatement, ContinueStatement, ReturnStatement, GlobalStatement, StaticStatement, EchoStatement, UnsetStatement, ExpStatement, ForEachStatement, CatchStatement, TryStatement, ThrowStatement,

PHP is weakly typed


<?php

$a = 12345;$a = “hello”;$a = array(12345, “hello”, array());$a = new Object();

$c = $a + $b; // integer or array$c = $a . $b; // implicit casting to strings

Core PHP library is small


- Most are in functional style- ~200 to 500 basic functions

<?php

$len = strlen(“hello”); // C library$ret = curl_exec($curl); // open source

PHP is easy to debug


<?php

function tally($count) { $sum = 0; for ($i = 0; $i < $count; ++$i) { $sum += $i; var_dump($sum); } return $sum;}

PHP is easy to learn


easy to read easy to write easy to debug

Hello, World!

PHP is slow


C++ Java C# Erlang Python Perl PHP0

10

20

30

40

http://shootout.alioth.debian.org/u64q/benchmark.php?

test=all&lang=all

CPU

Why is Zend Engine slow?

Byte-code interpreter Dynamic symbol lookups

functions, variables, constants class methods, properties,

constants Weakly typing

zval array()


Transforming PHP into C++


g++ is a native code compiler static binding

functions, variables, constants class methods, properties,

constants type inference

integers, strings, arrays, objects, variants

struct, vector, map, array

Static Binding – Function Calls


<?php$ret = foo($a);

// C++Variant v_ret;Variant v_a;

v_ret = f_foo(v_a);

Dynamic Function Calls


<?php$func = ‘foo’;$ret = $func($a);

// C++Variant v_ret;Variant v_a;String v_func;

V_func = “foo”;v_ret = invoke(v_func, CREATE_VECTOR1(v_a));

Function Invoke Table


Variant invoke(CStrRef func, CArrRef params) { int64 hash = hash_string(func); switch (hash) { case 1234: if (func == “foo”) return foo(params[0]) } throw FatalError(“function not found”);}

Re-declared Functions


<?phpif ($condition) { function foo($a) { return $a + 1;}} else { function foo($a) { return $a + 2;}}$ret = foo($a);

// C++if (v_condition) { g->i_foo = i_foo$$0; } else { g->i_foo = i_foo$$1;}g->i_foo(v_a);

Volatile Functions


<?phpif (!function_exists(‘foo’)) { bar($a);} else { foo($a);}function foo($a) {}

// C++if (f_function_exists(“foo”)) { f_bar(v_a);} else { f_foo(v_a);}g->declareFunction(“foo”);

Static Binding – Variables


<?php$foo = ‘hello’;function foo($a) { global $foo; $bar = $foo . $a; return $bar;}

// C++String f_foo(CStrRef v_a) { Variant &gv_foo = g->GV(foo); String v_bar; v_bar = concat(toString(gv_foo), v_a); return v_bar;}

GlobalVariables Class


class GlobalVariables : public SystemGlobals {public: // Direct Global Variables Variant gv_foo;

// Indirect Global Variables for large compilation enum _gv_enums { gv_foo, } Variant gv[1]; };

Dynamic Variables


<?phpfunction foo() { $b = 10; $a = 'b'; echo($$a);}

void f_foo() { class VariableTable : public RVariableTable { public: int64 &v_b; String &v_a; VariableTable(int64 &r_b, String &r_a) : v_b(r_b), v_a(r_a) {} virtual Variant getImpl(const char *s) { // hash – switch – strcmp } } variableTable(v_b, v_a);

echo(variableTable.get("b”));}

Static Binding – Constants


<?phpdefine(‘FOO’, ‘hello’);echo FOO;

// C++echo(“hello” /* FOO */);

Dynamic Constants


<?phpif ($condition) { define(‘FOO’, ‘hello’);} else { define(‘FOO’, ‘world’);}echo FOO;

// C++if (v_condition) { g->declareConstant("FOO", g->k_FOO, "hello”);} else { g->declareConstant("FOO", g->k_FOO, "world”);}echo(toString(g->k_FOO));

Static Binding with Classes

Class methods Class properties Class constants Re-declared classes Deriving from re-declared classes Volatile classes


Summary - Dynamic Symbol Lookup Problem is nicely solved

Rule of 90-10Dynamic binding is a general

form of static bindingGenerated code is a super-set of

static binding and dynamic binding


Problem 2. Weakly Typing

Type InferenceRuntime Type Info (RTTI)-Guided

OptimizationType HintsStrongly Typed Collection Classes


Type Coercions


Type Inference Example


<?php$a = 10;$a = ‘string’;

Variant v_a;

Why is strong type faster?


$a = $b + $c;

if (is_integer($b) && is_integer($c)) { $a = (int)$b + (int)$c;} else if (is_array($b) && is_array($c)) { $a = array_merge((array)$b + (array)$c);} else { …}

int64 v_a = v_b + v_c;

Type Inference Blockers


<?phpfunction foo() { if ($success) return 10; // integer return false; // doh’}

$arr[$a] = 10; // doh’

++$a; // $a can be a string actually!

$a = $a + 1; // $a can become a double, ouch!

RTTI-Guided Optimization


<?phpfunction foo($x) { ...}

foo(10);foo(‘test’);

void foo(Variant x) { ...}

Type Specialization Method 1


template<typename T>void foo(T x) { // generate code with generic T (tough!)}

-Pros: smaller generated code-Cons: no type propagation



void foo(int64 x) { // generate code assuming x is integer}void foo(Variant x) { // generate code assuming x is variant}

-Pros: type propagation-Cons: variant case is not optimized



void foo(int64 x) { // generate code assuming x is integer}void foo(Variant x) { if (is_integer(x)) { foo(x.toInt64()); return; } // generate code assuming x is variant}

-Pros: optimized for integer case-Cons: large code size

Type Hints


<?phpfunction foo(int $a) { string $b;}

class bar { public array $c;}

bar $d;

Strongly Typed Collection Classes

That omnipotent “array” in PHP

Swapping out underlying implementation:Array escalationPHP classes:

VectorSetMap: un-orderedThen Array: ordered map


Compiler Friendly Scripting Language

If all problems described here are considered when designing a new scripting language, will it run faster than Java?


hiphop compiler for php

Documents

confidentialhiphop compiler