This patch updates the PGM interface with the kernel.
Producers now boost their priority when generating tokens,
not consumers while waiting for tokens.

Adds routines for userspace tasks to use to communicate their
state to the Litmus kernel.

Adds macros for converting smaller time units into
bigger ones (ex. ns to s).

Renames the 'namespace' parameter to litmus_open_lock() forard
declaration in litmus.h to 'name_space'. This allows litmus.h
to be compiled by a C++ compiler. (Note: Using 'extern "C" {}'
does not work as an alternative solution.)

This patch replaces the algorithm used to compute
CPU affinity masks. The old algorithm was fragile
and would break on systems with multiple levels
of shared caches. (As found on some older Intel
chips, and as one would probably find on a system
with hyper-threading enabled.) The bug stems from
fact that Linux enumerates consecutive CPUs in a way
that distributes them across the physical system,
thereby reducing contention resources (e.g., cache).

The kernel needs to be able to deal with tasks that do not make
themselves a real-time task, but get configured by some other task
instead.

The sproadic_*() macros have become unwieldy. This patch
replaces those convenience macros for global, clustered,
and partitioned scheduling. A part of this API change
is the explicit use of nanosecond time-values. Prior APIs
have used lt_t (litmus time), which had an implied time
scale of nanoseconds.

/bin apps and test suite also updated to use revised API.
Modifications to the test suite are mostly centered around
using nanoseconds instead of milliseconds.

Adds init_rt_task_param(). Facilitates setting up default
real-time task attributes that cannot be set by memset(0).

This patch adds cluster scheduling options to
rtspin and rt_launch. The convenience routines
in litmus.h were also updated to facilitate
clustered scheduling. For partitioned scheduling,
just set cluster_size = 1 (default size for rtspin
and rt_launch).

This patch replaces be_migrate_to() with several
be_migrate_*() APIs to automatically assign CPU affinity
masks from a task's partition (or cluster) assignment.
Routines are release-master-aware such that the release
master (if one exists) will NOT be included in the
task's affinity mask. (Note that release-master
avoidance may be overridden by calling
__be_migrate_thread_to_cluster().)