Ignore compiled man pages in git diff

No need to see the ugly compiled troff output when running a diff.
Embed copy of cram

We use the cram Python module [1] for command-line testing — i.e., where
you want to run a command line program and verify its output in some
way.  Before we relied on the cram module being installed in some system
location.  But it's not very big, and it's only a single file, so lets
embed it directly in the source tree instead.  Now you only need to have
Python installed to be able to run the command-line tests.

[1] https://pypi.python.org/pypi/cram
Merge remote-tracking branch 'template/c-template' into develop

* template/c-template:
  Embed copy of cram
  Ignore compiled man pages in git diff
Remove bulk tasks

I want to try focusing on getting the scheduler code fast enough that we
don't need bulk tasks to achieve high performance.  It's an experiment,
but my hypothesis is that it will simplify the scheduler enough that we
might be able to squeeze some more performance out of it.
Customizable task migration and private deques

This patch implements the “receiver-initiated” stealing algorithm from
[1], which allows us to use private task deques within each execution
context.  This eliminates any slow synchronization primitives in the
fast path of each context's execution thread — each context is the only
entity that can push or pop tasks from any deques that it owns.  Tasks
steal from each other by communicating through some simple
message-passing channels:  First, the stealer task notifies the target
task that it wants to steal.  When the target notices this, it stops
executing tasks long enough to “migrate” some it tasks from its `ready`
deque into a special `migrating` deque.  Once this is done, it transfers
ownership of this `migrating` deque to the stealing context.  This
allows the stealing context to use this as its new `ready` deque, since
the ownership transfer allows it to pop tasks off of it.

This patch also implements a new `migrate` callback for tasks, which
allows a task to update its `ud` parameter when its moved from one
context to another.  (This can only happen before the task actually
executes; one the task starts executing its locked to a single context.)
This lets us implement a new `flt_local` API.  Before, a `struct
flt_local` was a single global pointer referring to a single
context-local data value.  You would use `flt_local_get` to retrieve the
context-specific pointer for that value.  We made this pretty fast, but
with the new API, you don't need the separate global pointer anymore.
Instead, you give the task the context-specific pointer for the context
that it's initially scheduled with.  If the task is ever migrated, then
only at that point do we have to update the pointer to point to a new
context value.  We optimize for the case that the new task will execute
in the same context as the task that created it.

[1] UA Acar, A Charguéraud, M Rainey.  “Scheduling parallel programs by
    work stealing with private deques.”  PPoPP 2013, ACM.
Remove task count from task deques

We can shave some cycles by not maintaining the per-context task count
each time we schedule and run a task.  That means that we have to walk
through more of the deque each time one context steals from another, but
we're not optimizing for the migration case, so that shouldn't be a
problem.
steps
tmp
tmp