HipHop is Facebook’s open source C++ compiler for PHP. HipHop (also known as HPHP) will compile your PHP code to highly optimized C++ code, which you can then compile (with g++) into a big binary that will run your web site (it includes a web server). If you want to know more about Hiphop and how it was created, you can check out the Facebook Engineering Blog article or the Github project.

After its introduction many bloggers have written background articles regarding Hiphop but few seem to have actually used it in a production environment. At Hyves, we use HipHop to run our web servers and our daemons, which are also written in in PHP. In this blog, I will detail some of our experiences and results.

Compiler and interpreter

Hiphop includes both and interpreter and a compiler. This is something that is not frequently mentioned in blog posts on Hiphop. The interpreter (called HPHPi) can be used for developing, thus saving you the hassle and the delays associated with compiling every time you change a single file. In general is has the same behavior as the compiled version of Hiphop. It is a bit slower than using PHP with an opcode cache, but it is not that bad and with a fast laptop it is still workable.

The compiler can be used to create an optimized binary for your code base. The Hyves code base is in the order of 3.5M LOC in PHP. The conversion from PHP to C++ has to be done by a single server, but we use a dedicated cluster of sixteen servers for compiling the C++ source code to an executable binary. This takes about seven minutes including the building (e.g. minimizing style sheets and javascript).

The resulting binary is approximately 500MB size. This cannot be deployed to our web servers in a serial fashion, as copying it would take too long. To deploy this to our web servers, we use a bittorent based p2p deploy system. In case of an emergency, we can roll out a fix in approximately ten minutes to our 300 web servers.

Update: Facebook just released a JIT compiling VM for Hiphop.

Behavioral differences

The HPHP interpreter, the compiled version and the official PHP binary all have slightly different behavior. HipHop is about 99% compatible with pure PHP. 99% times 3.5M LOC is a lot of problems. If you want to run HipHop, make sure that your unit tests are ran against all three versions automatically or you will drive yourself and your team members insane, especially in a mixed PHP / HPHP environment.

Some PHP 5.3 stuff is still not completely supported in Hiphop, such as namespaces, of which at the moment nearly every feature is broken. Extensions such as PHP’s SOAP extension have been ported but some behavior differences exist between the different runtimes.

Converting the Hyves code base to run on HipHop took a big effort, several of our software engineers worked on this projects for months.

Hiphop has some really cool features. There is a call_user_func_async() function (it does exactly what it says), and you can have two versions of you web site running at the same time, so that you can deploy a new version without downtime. Also, you can catch fatal (E_FATAL) errors with their stack traces with HPHP, a feature sorely lacking from PHP.

There is only sparse online documentation of these specific features so you will have to figure a lot of it our by reading the source code.

Performance

Performance of our Hiphop enabled web site has been very good. In particular our API has strongly benefited, with API calls being twice times as fast and requiring only a quarter of the cpu power compared to plain PHP. This has resulted in much faster mobile clients and better performance of the parts of our web site that use internal API calls.

In the top graph you can see our web servers 95% and 99% response times. We enabled HipHop for all our web servers in March 2011. The higher response times just before the switch are due to internal network congestions because of some issues with the first versions p2p deploy system we used.

The bottom graph shows the CPU load of our web servers, which has dropped by a factor of four after the switch to HipHop. This will enable us deprecate a big portion of our web servers in the future, resulting in high savings on hosting and power.

Open source

HipHop is an open source project, available on Github. If you file a bug, Facebook’s maintainers can be pretty responsive, well reported bugs can be fixed in a matter of days. Of course you can always fix it yourself on Github and try to get the fix pulled into the project.

Al though Facebook has reported that WordPress and Mediawiki are experimenting with HipHop, not many people actually seem to be using Hiphop in production. For now, the community is pretty small outside of Facebook.

Also Hyves contributed to the HipHop project, we contributed (among other things) bug reports, a number of bugfixes and the ability to use distcc so you can compile your web site on multiple machines.

Conclusion

All in all the switch to HipHop has been a big success for Hyves. Al though switching comes with a steep cost in terms of implementation and tooling, for a big web site such as Hyves it is definitely worth the effort. If you do not have at least a few dozen web servers, you should strongly consider buying more hardware in favor of spending a lot of effort on making Hiphop work for you.

Update

The original version of this article at the Hyves Product Development Blog made it to the front page of Hacker News.

Remote debugging UIWebView with the iOS simulator

For a little while people have figured out how to enable the remove inspector in iOS applications. With this trick, you can get a Webkit inspector (Opt+Cmd+I) for a UIWebView running in an app on the iPhone simulator. This will give you Weinre like abilities but it works much more reliably. Then, it didn’t take long before someone came up with an app to do all the GDB debugger attaching for you.

However, enabling the Webkit remote inspector is a private API call and if you have it in your application when you submit it to the App Store, your application will be rejected. Also, it only works on the simulator, if it runs on a device you cannot access the remote inspector because of firewall rules.

An easy solution is to include some precompiler directives that will only add the private API call when you compiled your app for the iOS simulator:

#if (TARGET_IPHONE_SIMULATOR)
    [NSClassFromString(@"WebView") _enableRemoteInspector]; // Private API call.
#endif

You need to import the TargetConditionals.h file too:

#ifdef __APPLE__
    #include "TargetConditionals.h"
#endif

You can access the remote inspector by loading your app in the iOS simulator and navigating to http://localhost:9999/.

Unfortunately, this feature is only available in the Google Chrome browser.

Included are a short reminder of what character sets are, how to use them, collation, best practices and common pitfalls. Finally, there are some tips for debugging issues with character sets.

If you have any questions after viewing this presentation, please ask.

1. Set the Eval.EnableXHP to true to that XHP will work on the interpreter if you need that. This will enable the XHP processor which will convert xml syntax to the __xhp classes.
2. Get the XHP PHP extension from https://github.com/facebook/xhp
3. Copy the files in the php-lib/ folder to your project
4. Include them in the source files where you want to use XHP.

One condition has to be met before it is possible to use multiple threads to process an iterator: each processing operation on an item in the operator must be independent on the other items. The typical PHP function to use in such cases is array_map(), which allows you to run a function over each item in an array. array_map() prohibits you to access other items in the iterator while processing an item, so the order of execution is not important.

In the past it has been very hard to effectively use parallelization in PHP. However, with Facebook’s Hiphop Facebook engineers have added the option to create threads in PHP using the call_user_func_async() function.

Some caveats apply:

• You can only create two extra threads, next to the main thread that is already running. Creating more threads doesn’t have any effects.
• Creating additional threads is expensive, so you have to carefully consider if it is worthwhile to use them.
• Unlike all other functions in PHP that accept functions as arguments, the call_user_func_async() does not accept anonymous functions as arguments. You need to pass in a string or array callback.
• The call_user_func_async() function is currently deprecated in HipHop and will issue a warning when called.

call_user_func_async() and array_map() can be combined into a parallel version of array_map(). This can be done by splitting the iterator in equal parts and then running the iterator over each part, each part in a separate thread. Finally, you need to put all the pieces back together (synchronize) by calling end_user_func_async() for each thread.

You can find my implementation at GitHub.

In practice the use of this function is limited: the maximum number of threads is three and there is quite a high cost for creating threads. However for complex processing or processing that calls external services (such as databases) that block it might be worth the extra effort.

After its introduction many bloggers have written background articles regarding Hiphop but few seem to have actually used it in a production environment. I have and here are some of my thoughts on working with Hiphop in such an environment.

Speed

Hiphop includes both and interpreter and a compiled version. This is something that is not frequently mentioned in blog posts about Hiphop. The interpreter (called HPHPi) can be used for developing, thus saving you the hassle and the delays associated with compiling every time you change a single file. (Compiling a simple 10 line script takes about one minute. This is probably because the web server has to be compiled too and this component is a few orders of magnitude more complex than my PHP script). In general is has the same behavior as the compiled version of Hiphop. It is a bit slower than using PHP with an opcode cache, but it is not that bad and with a fast laptop it is still workable.

The compiled version is really fast, at least a few times faster than using PHP with fastcgi. Also, Hiphop has become already three times as fast since it has been released in Februari 2010. So the speed is really, really good.

Behavioral differences

The HPHP interpreter, the compiled version and the official PHP interpreter will all give you ever so slightly different behavior. So make sure that your unit tests are ran against all three versions automatically or you will drive yourself and your team members insane, especially in a mixed PHP / HPHP environment.

Some PHP 5.3 stuff is still not completely supported in Hiphop, such as namespaces, of which at the moment nearly every feature is broken. Support for anonymous functions have only recently been added. Extensions such as PHP’s SOAP extension have been ported but some behavior varies between the variants. Small stuff mostly. For example, if you get a SoapFault exception somewhere, in PHP the exception will contain the message from the SOAP response, but in HPHP the exception will contain the entire SOAP response.

If you want to write scripts that are PHP and HPHP compatible, you will need to write some if statements here and there. Definitely test all your code against the compiled, interpreted and official PHP binary.

Features

Hiphop has some really cool features. There is a call_user_func_async() function (it does exactly what it says), and you can have two versions of you web site running at the same time, so that you can deploy a new version without downtime. Also, you can catch fatal (E_FATAL) errors with their stack traces with HPHP, a feature sorely lacking from PHP. There is only sparse online documentation of these specific features, but you can set up your own documentation server.

Among these new features, HPHP introduces some new errors that can occur in your scripts, mostly when you do strange stuff which you are not supposed to some datatypes., but PHP still allows. For example, in PHP this will not throw any errors: $var = null; $var['foo'] = ‘bar’;. In HPHP, this will throw an E_NOTICE. I will leave it as an exercise to the reader to decide which of the two behaviors actually is preferred. In general, HPHP is more strict and less forgiving, so that will probably cause latent bugs in your project to rise to the surface.

You gain some, you loose some: some PHP features such as fastcgi_finish_request() are not available under Hiphop. If you want any of the non included PHP extensions, you will have to port them to C++ yourself. Since they are already in C, it is not hard but you still need to do it.

Open source

One of the great things about Hiphop is that is is an open source project. The code for Hiphop is shared on Github. If you file a bug, Facebook’s maintainers can be pretty responsive. I filed a one (behavior difference from PHP for anonymous functions) and it was fixed four days later. Of course you can always fix it yourself on Github and try to get the fix pulled into the project. Not many people are actually using Hiphop in production, so the community is pretty small outside of Facebook.

Conclusions

Facebook’s Hiphop is really, really fast and offers useful features. However, you can imaging that with the behavioral differences and the changes you will need to your build and deploy process it may or may not be worth it for your web site.

Many programmers assume that when the __call() method returns false, this will indicate to the PHP interpreter that the requested method is not (dynamically) available and that the normal error handling will then take over and trigger an E_FATAL error.

This is not the case in PHP! The method call will complete successfully, returning false. So if you make a typo or whatever there will not be an error, but it will silently succeed. This is a bit unintuitive, because in other cases returning false will trigger the default behavior in PHP. For example, if you set a custom error handler and have it return false, the normal error handler will take over. But with overloading methods this works a bit different.

The best way to deal with this is by raising an error or throwing an exception from the __call() method whenever you are unsure what to do with the dynamic method call. The Standard PHP library provides the excellent BadMethodCallException, which you can throw when there is a – you guessed it – bad method call.

An example with dynamic getters and setters:

class a {
    private $foo = "bar";
    public function __call($method, $args) {
        $property = substr($method,3);
        if (substr($method, 0, 3) == 'get' && isset($this->$property)) {
            return $this->$property;
        }

        if (substr($method, 0, 3) == 'set' && isset($this->$property)) {
            $this->$property = $args[0];
            return;
        }
        throw new BadMethodCallException();
    }
}

Some background information: Filevault creates an encrypted disk image that contains your user profile. When files are deleted from your profile, the encrypted disk image does not get resized. Resizing only happens when you log out, you will see the “Filevault is recovering disk space” message. This only takes a few seconds and will resize the encrypted disk image to the actual needed size. If you log back in, you will see that the free disk space is now there.

In this post, I mainly want to discuss the differences between PHP’s foreach control structure and the array_map() function. Both methods allow you to iterate over an array. As an example I present two methods to calculate the squares of all elements in an array. The traditional foreach approach would be something like

foreach ($array as $key => $value) {
    $array[$key] *= $value;
}

Quite the difference compared with an anonymous function and array_map():

$array = array_map(function($each) { return $each * $each;}, $array);

Both approaches have very different characteristics, I will discuss these in this post.

Performance

There exists a big performance gap between the two methods. The fastest is the foreach construct. This construct can about 70% faster than an anonymous function, at least when there is not much to do within the loop (see comments below). In most scenarios, the time it takes to iterate over the array is negligible compared to the time spend in the loop or anonymous function. So this performance difference does not really matter.

An interesting difference is peak memory usage. With big arrays, the peak memory usage of the array_map() function may be 2.5 times as much as the foreach loop. This is probably because this function creates an in memory copy of the array. If you have really big arrays, this can become a problem. One way to deal with this is to pass the array (second) argument to array_map() by reference (using the & operator). Although this is deprecated, it can reduce memory usage to a “mere” twice as much as a foreach loop.

Default anonymous functions

Anonymous functions cannot be used as default values for class properties or function arguments. This is probably because the anonymous function is internally represented by the Closure class.

If you want to have a default function argument for a function, you will have to use null and check for that in  the function. Default functions as arguments can be very useful for functions that accept functions as arguments. The following examples will unfortunately gives you a compile error (unexpected T_FUNCTION):

public function reduce(array $array, $function = function($each) { return !$each;}) {
    return array_filter($array, $function);
}

You will have to move the default value into the function:

public function reduce(array $array, Closure $function = null) {
    if ($function === null) {
        $function = function($each) { return !$each; };
    }
    return array_filter($array, $function);
}

It is possible to use typehinting to signal that you want a function as an argument for a function. You can do this by using the Closure class. However, the PHP documentation clearly specifies that no code should rely on this class. In future PHP versions, the class might be renamed or replaced altogether.

Scoping

An advantage of using anonymous functions to iterate over arrays is in scoping. PHP has very little support for scoping as compared to, for example, C. The foreach example above will leave $key and $value available after the loop has been completed. Although this can be very useful, it can also be confusing and lead to bugs. For example, $value could overwrite a variable with the same name set earlier. These kind of bugs might be very hard to spot.

Within the anonymous function all used variables are properly scoped and cannot influence outside variables unless specifically specified with the use statement. After the iteration has been completed, no variables are left lingering around.

break and continue

The foreach loop allows you to use break and continue statements to break out of the loop or out of the current iteration of the loop. This can be very beneficial for performance reasons. Imagine that you would like to check if all elements of an array are non-empty. With foreach, you can just break out of the loop when you encounter the first empty element. With array_map() this is not possible.

The Prototype Javascript library solves this by introducing two special Exceptions, $break and $continue. When either of these exceptions is thrown, the iteration over the array is stopped and prototype makes sure that the correct behavior the occurs. As PHP does not have these magical exceptions implemented, you would need to create them yourself.

Miscellaneous

Foreach allows you access the other elements in the array too, for example to compare the current value with the previous one (if you use the $key => $value syntax). This is not possible with the array_map() and array_walk() functions.

The syntax for foreach has a few caveats. You cannot write to the $value variable, unless you write a foreach statment by reference or reference the array and its key:

foreach ($array as &$value) $value *= $value;
foreach ($array as $key => $value) $array[$key] *= $value;

Either will work.

Finally, if you use Facebook’s Hiphop compiler for PHP to speed up your web site, you have a problem as the anonymous function syntax is not yet supported by Hiphip. In that case you will have to fall back to your old friend create_function(). This leaves you without the pretty syntax and support for the use argument.

Conclusion

Ultimately, both foreach and the array_map() + anonymous functions have their pros and cons. Anonymous functions are especially suited for operations that change all values of an array. They also offer strickt scoping which can prevent bugs.

There is also a strong matter of personal preference involved. With anonymous functions you can write your code in a totally new style. If you like this and can deal with the lack of continue and break, anonymous functions may be the way to go. For example, it is not very hard to implement Prototype’s Enumerable in PHP with the use of array_map() and anonymous functions.

If you are more a procedural type of guy (or girl), stick with the foreach control structure.