HipHop Compiler for PHP

1. HipHop Compiler for PHP Transforming PHP into C++ HipHop Compiler Team Facebook, Inc. May 2010

2. 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”;

3. 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);

4. PHP Statements and Expressions • 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, • ExpressionList, • AssignmentExpression, • SimpleVariable, • DynamicVariable, • StaticMemberExpression, • ArrayElementExpression, • DynamicFunctionCall, • SimpleFunctionCall, • ScalarExpression, • ObjectPropertyExpression, • ObjectMethodExpression, • ListAssignment, • NewObjectExpression, • UnaryOpExpression, • IncludeExpression, • BinaryOpExpression, • QOpExpression, • ArrayPairExpression, • ClassConstantExpression, • ParameterExpression, • ModifierExpression, • ConstantExpression, • EncapsListExpression,

5. 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

6. 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

7. PHP is easy to debug • <?php • function tally($count) { • $sum = 0; • for ($i = 0; $i < $count; ++$i) { • $sum += $i; • var_dump($sum); • } • return $sum; • }

8. PHP is easy to learn • easy to read • easy to write • easy to debug • Hello, World!

9. PHP is slow 

10. Why is Zend Engine slow? • Byte-code interpreter • Dynamic symbol lookups • functions, variables, constants • class methods, properties, constants • Weakly typing • zval • array()

11. 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

12. Static Binding – Function Calls • <?php • $ret = foo($a); • // C++ • Variant v_ret; • Variant v_a; • v_ret = f_foo(v_a);

13. 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));

14. Function Invoke Table • Variant invoke(CStrReffunc, CArrRefparams) { • int64 hash = hash_string(func); • switch (hash) { • case 1234: • if (func == “foo”) return foo(params[0]) • } • throw FatalError(“function not found”); • }

15. Re-declared Functions • <?php • if ($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);

16. Volatile Functions • <?php • if (!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”);

17. Static Binding – Variables • <?php • $foo = ‘hello’; • function foo($a) { • global $foo; • $bar = $foo . $a; • return $bar; • } • // C++ • String f_foo(CStrRefv_a) { • Variant &gv_foo = g->GV(foo); • String v_bar; • v_bar = concat(toString(gv_foo), v_a); • return v_bar; • }

18. 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]; • };

19. Dynamic Variables • <?php • function 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”)); • }

20. Static Binding – Constants • <?php • define(‘FOO’, ‘hello’); • echo FOO; • // C++ • echo(“hello” /* FOO */);

21. Dynamic Constants • <?php • if ($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));

22. Static Binding with Classes • Class methods • Class properties • Class constants • Re-declared classes • Deriving from re-declared classes • Volatile classes

23. Summary - Dynamic Symbol Lookup Problem is nicely solved  • Rule of 90-10 • Dynamic binding is a general form of static binding • Generated code is a super-set of static binding and dynamic binding

24. Problem 2. Weakly Typing • Type Inference • Runtime Type Info (RTTI)-Guided Optimization • Type Hints • Strongly Typed Collection Classes

25. Type Coercions

26. Type Inference Example • <?php • $a = 10; • $a = ‘string’; • Variant v_a;

27. 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;

28. Type Inference Blockers • <?php • function 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!

29. RTTI-Guided Optimization • <?php • function foo($x) { • ... • } • foo(10); • foo(‘test’); • void foo(Variantx) { • ... • }

30. Type Specialization Method 1 • template<typename T> • void foo(Tx) { • // generate code with generic T (tough!) • } • -Pros: smaller generated code • -Cons: no type propagation

31. Type Specialization Method 2 • void foo(int64 x) { • // generate code assuming x is integer • } • void foo(Variantx) { • // generate code assuming x is variant • } • Pros: type propagation • Cons: variant case is not optimized

32. Type Specialization Method 3 • void foo(int64 x) { • // generate code assuming x is integer • } • void foo(Variantx) { • if (is_integer(x)) { • foo(x.toInt64()); return; • } • // generate code assuming x is variant • } • Pros: optimized for integer case • Cons: large code size

33. Type Hints • <?php • function foo(int$a) { • string $b; • } • class bar { • public array $c; • } • bar $d;

34. Strongly Typed Collection Classes • That omnipotent “array” in PHP  • Swapping out underlying implementation: • Array escalation • PHP classes: • Vector • Set • Map: un-ordered • Then Array: ordered map

35. Compiler Friendly Scripting Language If all problems described here are considered when designing a new scripting language, will it run faster than Java?