las3_pub / predictable_parallel_patterns

We changed how the memory is allocated from passing char* buffers to then store objects into to creating 'fat objects' for all scheduler state. This eases development for us, as we can make changes to data structures without too much effort (e.g. add a second array to manage tasks if required).

This allows us to more easily handle them and makes their interface closer to std::thread.

The scheduler yields if it failed to steal any work due to the task
lists being empty. This should improve performance on multiprogrammed
systems, as it potentially makes room for other worker threads which
still have work to perform.

This allows the stack and deque class to use the same offset, making it work better with each other.

Threads must be joined on scheduler termination and tasks must be pushed onto the stack to allow better memory management.

This was highlighted as an issue in the steal_work routine, as frequent calls to virtual functions are expensive.

Please note that this does currently not execute, but only removed the 'old aspecs'. We are still missing launching the root fork_join task.

This is required to correctly execute multiple, consecutive wait_for_all calls in one fork_join_sub_task.

These currently do nothing but being boilerplate required to implement a new top level task.

We do this to properly separate the cache alginment logic in the next step, allowing us to port all cache aligned objects without worrying about portability.

We do so by pulling out the profiling macros in our own iclude file. In the future we might even be able to use this to build up further visualisations of the executing programm.

Use only placement new on pre-allocated memory. This makes sure that we have to have no assumptions on the inital state of the memory region.

This lead to some bug-fixes that covered move constructors not correctly assigning memory. We might clean this up further by only allowing in place creation of these types (placement new).

There are serval ways we could optimize the calls, but for now this should be enough for first tests.

The current solution is not clean, but allows us to change error handling later on without missing any point in the programm where we would want to use it.