unittest for doing a controlled simulation of job queue workload

A simple framework for doing a controlled simulation on job queue. Within this
set up, we can specify a duration for each request going through the system. The
request will have a fixed service duration of x ticks. We define our own
TickWorker that finishes the request after x ticks. We have a static global
logical clock we can then use to drive the simulation.

The next step is to generate a reasonable workload based on our real work
request latency distribution and run it through the system. After that, we can
simulate server side issues (ie. all reqeusts incur additional latency or small
percentage of request with very high latency).

The test case will help us select and fine tune the algorithm for doing queuing
and timeouts.

Reviewed By: rkroll

Differential Revision: D1043222
PHP integers are 64 bits

The fact that ArrayData::m_size is uint32_t complicated things a bit.

Reviewed By: @bertmaher

Differential Revision: D1043095
Add PushL for use in continuations

PushL pushes the value of a local on the stack and unsets it, avoiding
any refcounting operations. This is useful in Continuation::send and async
functions.

Reviewed By: @ottoni

Differential Revision: D1042054
Sort the expect files alphabetically.

Let's sort the expect files alphabetically so any changes to them doesn't result in mega-diffs.... well, this will be the last mega diff to prime the expect files :)

Reviewed By: @ptarjan

Differential Revision: D1044747
parity: move gc_enable warnings behind hip hop syntax

... and make gc_disable emit no warnings, since it's a 100%
 effective no-op.

Reviewed By: @ptarjan

Differential Revision: D1044225
parity: make ZipArchive Not Implemented errors informative

... throwing ##"Not implemented is not implemented"## does
 not cover oneself in glory. Easy fix with a few emacs macros

Reviewed By: @ptarjan

Differential Revision: D1044243
Inline small cold functions into hot ones

I noticed some missed opportunities for inlining were because the
callee was not marked as hot, but the caller was.  There's a check to
prevent inlining in such case, which kind of makes sense -- the call
may be in a cold path.  However, in some cases the callee is not
marked as hot probably just because it's too small.  And if the
function is small enough it's better to inline it anyway -- they code
may get smaller.  So I added a callee code-size threshold below which
inlining is always allowed.

I did some experiments with different values for the new threshold,
and also the previously existing HHIRInliningMaxCost, and set them to
what seems best these days.

Reviewed By: @jdelong

Differential Revision: D1044965