Add support for hash sets to stl-hashmap.h
Add support for identifying and extracting local and global resources
Add holistic MSRP analysis (with PCP/SRP for local resources)

This patch adds holistic analysis of the MSRP, which combines the PCP/SRP
for local resources and task-fair mutex spin locks for global resources.

This is added as its own analysis (rather than patching the task-fair mutex
code directly) because
- the MSRP only applies to partitioned scheduling, and
- to not break existing code that does not expect special treatment of local resources.

Simple tests included. Adds some convenience code to Interference and BlockingBounds.
Keep track of spin-delay in clustered/mutex analysis

For non-suspension-oblivious analysis, we need to keep track of
the spin delay separately. Store it as 'remote blocking'.
Provide Python wrapper for msrp_bounds_holistic()

...and a bunch of extra comments in C++ analysis.
bugfix: include/linprog/solver.h: used float as variable index
Added support for binary/integer variables in the C++ LP model

Added functions to declare variables as integer or binary in C++ LP model.
These declarations are currently supported by the CPLEX backend; the GLPK
backend currently does not respect these declarations, i.e., all variables
are treated as floats as it used to be.
added safety check for CPLEX solver (C-API): abort on binary/integer variables

Make CPLEX fail when some variables are declared binary/integer and the old
C-API of CPLEX is used. Binary/integer variables are currently not supported.
Add ILP support to GLPK bridge

In the testmain MSRP case, the produces the same numbers as CPLEX.
use GLPK by default
do not add empty requests to C++ resmodel

This patch ensures that no "empty" requests (number of requests = 0 in a Python
ResourceRequirement instance) are considered when the C++ model for a task set
is created.
incorporated request priority into Python resource model
incorporated request priority into C++ resource model
added getter function for raw remote blocking Interference in BlockingBounds

Used in the C++ implementation of the classic MSRP blocking analysis.
C++ helper function split_by_clusters: allow initialization with number of processors

This can avoid issues when the no task is assigned to the last partition, in
which case the existing code would leave the last partions in the Clusters
data structure uninitialized.
implement classic (non-LP, non-holistic) MSRP analysis for comparison
export holistic analysis for MSRP to Python
Added VarMapperSpinlocks, a specialized VarMapper for spinlocks

VarMapperSpinlocks is a subclass of VarMapper, that in addition resolves the
A_q variables, that tell whether requests to resource l_q can cause the
current task to incur arrival blocking.
added common constraints and helper functions for the analysis of spinlocks
added constraints for the analysis of MSRP