Fix typo in schedcat/sched/__init__.py:get_native_taskset()

If there is no priority point set for a Task, the GEL work triggered
an AttributeError due to a typo.
Do not overwrite Task.jitter in FP overhead accounting

If the parameter already exists, then it should be inflated, not
overwritten.
Move get_priority_ceilings() from DPCP to common code

The LP-based analysis of the DPCP can reuse this, so make it
available globally.
MPCP: we must consider gcs' with equal priority ceilings

gcs' with equal priority ceiling cannot be preempted.
MPCP: report local and remote blocking even if >response_time

To make response times monotonically increasing, it is beneficial
to have some estimate even if the response_time assumption has
been violated.
MPCP: export gcs response-time bounds

This will be used by the new LP-based MPCP analysis.

Also, report local blocking to Python and add a clarifying comment.
MPCP: accurately track per-processor priority ceilings

The priority ceilings under the MPCP are defined in a way
such that one processor has a slightly lower ceiling.
This doesn't really affect the outcome much, but this patch
changes the analysis to be exactly as defined for the sake
of accuracy.
Add benchmarking helper class

CPUClock is useful for repeatedly measuring how long
some piece of code executes.
Extract hash map hack from rw-task-fair.cpp

Hashmaps will be needed by the LP code.

Additionally, add definitions for hash maps with uint64_t keys.
This is only relevant for legacy C++ libs as used on Mac OS X.
On Linux, we use the newer C++ '11 STL implementation.
Extract sharedres_types.h from sharedres.h

The LP code requires many of the same definitions. Therefore, this patch splits the reusable
type definitions into an individual file to facilitate inclusion.
Simplify sharedres_types.h with iterator macros

Explicit iterator handling is cumbersome. Hide it when possible.
Add unique IDs to TaskInfo

The LP code generates variable IDs based on task identity.
It's convenient to keep track of this explicitly.
Add simple C++ linear program representation

- Constraints are expressed as lists of terms.
- Linear programs consist of only equalities and less-than-or-equal constraints.
- Solvers hide behind an abstract solution class that can evaluate
  linear expressions.
Add CPLEX integration

This patch introduces a concrete subclass of Solution that implements the actual
solving of linear programs by means of invoking the CPLEX Concert Technology API.

The project can still be compiled on systems that do not have CPLEX installed.
Add DPCP and DFLP linear program generation

These files implement the generation and evaluation of linear programs
that bound maximum s-aware pi-blocking under the DPCP and the DFLP.
Allow VarMapper to start at index other than 0

This is in preparation of merged LPs.
Add compile-time support for merged LPs

This patch introduces the capability to generate
one huge LP for an entire task set, instead of
generating many smaller LPs (one for each task).

It's not clear yet that this is actually any faster.
Export the LP-based analysis of the DFLP/DPCP

...via Swig to Python. The actual Python API will
be finalized later.
Add test code for LP-based DPCP/DFLP analysis
Add memory leak debug code to testmain

The CPLEX integration likes to leak memory. This loop makes it very
obvious.