Use Intel TBB's parallel_sort even for nested parallelism.

TBB has a global task scheduler (that's one of the reason TBB is not
linked statically but dyanmically instead). This allows control over all
running threads, enabling us to use nested parallelism and the scheduler
doing all the task allocation itself.

That is, nested parallel execution such as in

    parallel_for(seq, [](const auto& rng){
      parallel_sort(rng);
    });

is no problem at all, as the scheduler still claims control over the
global environment.

Therefore, use `parallel_sort` Range overload where possible.

References:

- https://www.threadingbuildingblocks.org/docs/help/hh_goto.htm#reference/algorithms.htm
- https://www.threadingbuildingblocks.org/docs/help/hh_goto.htm#reference/algorithms/parallel_sort_func.htm
- https://www.threadingbuildingblocks.org/docs/help/hh_goto.htm#reference/task_scheduler.htm
- https://www.threadingbuildingblocks.org/docs/help/hh_goto.htm#reference/task_scheduler/task_scheduler_init_cls.htm
- https://www.threadingbuildingblocks.org/docs/help/hh_goto.htm#tbb_userguide/Initializing_and_Terminating_the_Library.htm

routing_algorithms/alternative_path.hpp

@@ -35,10 +35,14 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include <boost/assert.hpp>
 
+#include <tbb/parallel_sort.h>
+
 #include <unordered_map>
 #include <unordered_set>
 
 #include <vector>
+#include <algorithm>
+#include <utility>
 
 const double VIAPATH_ALPHA = 0.10;
 const double VIAPATH_EPSILON = 0.15; // alternative at most 15% longer
@@ -60,6 +64,7 @@ class AlternativeRouting final
         {
         }
 
+
         NodeID node;
         int length;
         int sharing;
@@ -287,7 +292,7 @@ class AlternativeRouting final
                 ranked_candidates_list.emplace_back(node, length_of_via_path, sharing_of_via_path);
             }
         }
-        std::sort(ranked_candidates_list.begin(), ranked_candidates_list.end());
+        tbb::parallel_sort(ranked_candidates_list);
 
         NodeID selected_via_node = SPECIAL_NODEID;
         int length_of_via_path = INVALID_EDGE_WEIGHT;

routing_algorithms/direct_shortest_path.hpp

@@ -30,12 +30,18 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include <boost/assert.hpp>
 
+#include <tbb/parallel_sort.h>
+
 #include "routing_base.hpp"
 #include "../data_structures/search_engine_data.hpp"
 #include "../util/integer_range.hpp"
 #include "../util/timing_util.hpp"
 #include "../typedefs.h"
 
+#include <vector>
+#include <algorithm>
+#include <utility>
+
 /// This is a striped down version of the general shortest path algorithm.
 /// The general algorithm always computes two queries for each leg. This is only
 /// necessary in case of vias, where the directions of the start node is constrainted
@@ -161,8 +167,8 @@ class DirectShortestPathRouting final
             {
                 return lhs.first < rhs.first || (lhs.first == rhs.first && lhs.second < rhs.second);
             };
-        std::sort(forward_entry_points.begin(), forward_entry_points.end(), entry_point_comparator);
-        std::sort(reverse_entry_points.begin(), reverse_entry_points.end(), entry_point_comparator);
+        tbb::parallel_sort(forward_entry_points, entry_point_comparator);
+        tbb::parallel_sort(reverse_entry_points, entry_point_comparator);
 
         NodeID last_id = SPECIAL_NODEID;
         for (const auto p : forward_entry_points)