Squashed 'libs/EXTERNAL/libtatum/' changes from 7fc65f57e..4e4583163

4e4583163 Remove Cilk Plus support since it is no longer supported by new compilers

git-subtree-dir: libs/EXTERNAL/libtatum
git-subtree-split: 4e45831638996f9e63ef7cf8737aac03b755debe

Author: kmurray

.travis.yml

@@ -14,9 +14,6 @@ matrix:
         - env: TESTS="basic mcnc20" TATUM_EXECUTION_ENGINE=tbb MATRIX_EVAL="CC=gcc-5 CXX=g++-5"
           addons: { apt: { packages: ["cmake", "g++-5", "libtbb-dev"], sources: ["ubuntu-toolchain-r-test"] } }
 
-        - env: TESTS="basic mcnc20" TATUM_EXECUTION_ENGINE=cilk MATRIX_EVAL="CC=gcc-5 CXX=g++-5"
-          addons: { apt: { packages: ["cmake", "g++-5", "libtbb-dev"], sources: ["ubuntu-toolchain-r-test"] } }
-
         #Simple testing for other compilers
         - env: TESTS="basic" TATUM_EXECUTION_ENGINE=auto MATRIX_EVAL="CC=gcc-8 CXX=g++-8"
           addons: { apt: { packages: ["cmake", "g++-8", "libtbb-dev"], sources: ["ubuntu-toolchain-r-test"] } }

CMakeLists.txt

@@ -3,7 +3,7 @@ cmake_minimum_required(VERSION 2.8.12)
 project("tatum")
 
 set(TATUM_EXECUTION_ENGINE "auto" CACHE STRING "Specify the framework for (potential) parallel execution")
-set_property(CACHE TATUM_EXECUTION_ENGINE PROPERTY STRINGS auto serial cilk tbb)
+set_property(CACHE TATUM_EXECUTION_ENGINE PROPERTY STRINGS auto serial tbb)
 
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules")
 

libtatum/CMakeLists.txt

@@ -6,34 +6,8 @@ project("libtatum")
 #Check for parallel execution framework support
 #
 #
-set(CILK_PLUS_SUPPORTED FALSE)
 set(TBB_SUPPORTED FALSE)
 
-# Determine if the compiler has Cilk Plus support
-#  This is required for the analyzer to run in parallel mode
-#  As of April 2015 the following compilers have full support
-#  for Cilk Plus:
-#    * GCC 5+ (Note: GCC 4.9 has only partial support, it does support the cilk_for keyword)
-#    * Intel
-#
-# Note that Cilk Plus is considered deprecated as of GCC 7, and Intel 2018
-include(CheckCXXCompilerFlag)
-
-set(CMAKE_REQUIRED_FLAGS "-fcilkplus -lcilkrts")
-#Check for cilk_for support, since some compilers like gcc 4.9
-#supports cilk but not cilk_for
-CHECK_CXX_SOURCE_COMPILES("#include <cilk/cilk.h>
-                           int main(int argc, char** argv) {
-                               int cnt = 0;
-                               cilk_for(int i = 0; i < 10; i++) {
-                                   cnt++;
-                               }
-                           }" COMPILER_SUPPORTS_CILK_PLUS)
-
-if (COMPILER_SUPPORTS_CILK_PLUS)
-    set(CILK_PLUS_SUPPORTED TRUE)
-endif()
-
 #Check for Thread Building Blocks support
 find_package(TBB)
 
@@ -52,18 +26,12 @@ if (TATUM_EXECUTION_ENGINE STREQUAL "auto")
     #Pick the best supported execution engine
     if (TBB_SUPPORTED)
         set(TATUM_USE_EXECUTION_ENGINE "tbb")
-    elseif (CILK_PLUS_SUPPORTED)
-        set(TATUM_USE_EXECUTION_ENGINE "cilk")
     else()
         set(TATUM_USE_EXECUTION_ENGINE "serial")
     endif()
 else()
     #The user requested a specific execution engine
-    if (TATUM_EXECUTION_ENGINE STREQUAL "cilk")
-        if (NOT CILK_PLUS_SUPPORTED)
-            message(FATAL_ERROR "Tatum: Requested execution engine '${TATUM_EXECUTION_ENGINE}' not found")
-        endif()
-    elseif (TATUM_EXECUTION_ENGINE STREQUAL "tbb")
+    if (TATUM_EXECUTION_ENGINE STREQUAL "tbb")
         if (NOT TBB_SUPPORTED)
             message(FATAL_ERROR "Tatum: Requested execution engine '${TATUM_EXECUTION_ENGINE}' not found")
         endif()
@@ -103,25 +71,7 @@ set_target_properties(libtatum PROPERTIES PREFIX "") #Avoid extra 'lib' prefix
 target_include_directories(libtatum PUBLIC ${LIB_TATUM_INCLUDE_DIRS})
 
 #Setup parallel execution
-if (TATUM_USE_EXECUTION_ENGINE STREQUAL "cilk")
-    message(STATUS "Tatum: will support parallel execution using '${TATUM_USE_EXECUTION_ENGINE}'")
-
-    message(WARNING "Tatum: Cilk Plus support is deprecated and will be removed in the future")
-
-    #Compile with parallel support
-    # Since we the analyzer's are C++ templates, clients must compile
-    # with cilk to enable parallel analysis
-    target_compile_options(libtatum PUBLIC "-fcilkplus")
-
-    target_compile_definitions(libtatum PUBLIC TATUM_USE_CILK)
-    if (TBB_SUPPORTED)
-        target_link_libraries(libtatum tbbmalloc_proxy) #Use the scalable memory allocator
-    endif()
-
-    #Link to the cilk run-time
-    target_link_libraries(libtatum cilkrts)
-
-elseif (TATUM_USE_EXECUTION_ENGINE STREQUAL "tbb")
+if (TATUM_USE_EXECUTION_ENGINE STREQUAL "tbb")
     message(STATUS "Tatum: will support parallel execution using '${TATUM_USE_EXECUTION_ENGINE}'")
 
     target_compile_definitions(libtatum PUBLIC TATUM_USE_TBB)

libtatum/tatum/graph_walkers/ParallelLevelizedWalker.hpp

@@ -3,11 +3,6 @@
 #include "tatum/graph_visitors/GraphVisitor.hpp"
 #include "tatum/TimingGraph.hpp"
 
-#ifdef TATUM_USE_CILK
-# include <cilk/cilk.h>
-# include <cilk/reducer_opadd.h>
-#endif
-
 #ifdef TATUM_USE_TBB
 # include <tbb/parallel_for_each.h>
 # include <tbb/combinable.h>
@@ -18,8 +13,8 @@ namespace tatum {
 /**
  * A parallel timing analyzer which traveres the timing graph in a levelized
  * manner.  However nodes within each level are processed in parallel using
- * Cilk Plus. If Cilk Plus is not available it operates serially and is 
- * equivalent to the SerialWalker
+ * Thread Building Blocks (TBB). If TBB is not available it operates serially and is 
+ * equivalent to the SerialWalker.
  */
 class ParallelLevelizedWalker : public TimingGraphWalker {
     public:
@@ -28,19 +23,7 @@ class ParallelLevelizedWalker : public TimingGraphWalker {
 
             LevelId first_level = *tg.levels().begin();
             auto nodes = tg.level_nodes(first_level);
-#if defined(TATUM_USE_CILK)
-            //Use reducer for thread-safe sum
-            cilk::reducer<cilk::op_add<size_t>> unconstrained_reducer(0);
-
-            cilk_for(auto iter = nodes.begin(); iter != nodes.end(); ++iter) {
-                bool constrained = visitor.do_arrival_pre_traverse_node(tg, tc, *iter);
-
-                if(!constrained) {
-                    *unconstrained_reducer += 1;
-                }
-            }
-            num_unconstrained_startpoints_ = unconstrained_reducer.get_value();
-#elif defined(TATUM_USE_TBB)
+#if defined(TATUM_USE_TBB)
             tbb::combinable<size_t> unconstrained_counter(zero);
 
             tbb::parallel_for_each(nodes.begin(), nodes.end(), [&](auto node) {
@@ -66,20 +49,7 @@ class ParallelLevelizedWalker : public TimingGraphWalker {
         void do_required_pre_traversal_impl(const TimingGraph& tg, const TimingConstraints& tc, GraphVisitor& visitor) override {
             num_unconstrained_endpoints_ = 0;
             const auto& po = tg.logical_outputs();
-#if defined(TATUM_USE_CILK)
-            //Use reducer for thread-safe sum
-            cilk::reducer<cilk::op_add<size_t>> unconstrained_reducer(0);
-
-            cilk_for(auto iter = po.begin(); iter != po.end(); ++iter) {
-                bool constrained = visitor.do_required_pre_traverse_node(tg, tc, *iter);
-
-                if(!constrained) {
-                    *unconstrained_reducer += 1;
-                }
-            }
-
-            num_unconstrained_endpoints_ = unconstrained_reducer.get_value();
-#elif defined(TATUM_USE_TBB)
+#if defined(TATUM_USE_TBB)
             tbb::combinable<size_t> unconstrained_counter(zero);
 
             tbb::parallel_for_each(po.begin(), po.end(), [&](auto node) {
@@ -106,11 +76,7 @@ class ParallelLevelizedWalker : public TimingGraphWalker {
         void do_arrival_traversal_impl(const TimingGraph& tg, const TimingConstraints& tc, const DelayCalculator& dc, GraphVisitor& visitor) override {
             for(LevelId level_id : tg.levels()) {
                 auto level_nodes = tg.level_nodes(level_id);
-#if defined(TATUM_USE_CILK)
-                cilk_for(auto iter = level_nodes.begin(); iter != level_nodes.end(); ++iter) {
-                    visitor.do_arrival_traverse_node(tg, tc, dc, *iter);
-                }
-#elif defined(TATUM_USE_TBB)
+#if defined(TATUM_USE_TBB)
                 tbb::parallel_for_each(level_nodes.begin(), level_nodes.end(), [&](auto node) {
                     visitor.do_arrival_traverse_node(tg, tc, dc, node);
                 });
@@ -125,11 +91,7 @@ class ParallelLevelizedWalker : public TimingGraphWalker {
         void do_required_traversal_impl(const TimingGraph& tg, const TimingConstraints& tc, const DelayCalculator& dc, GraphVisitor& visitor) override {
             for(LevelId level_id : tg.reversed_levels()) {
                 auto level_nodes = tg.level_nodes(level_id);
-#if defined(TATUM_USE_CILK)
-                cilk_for(auto iter = level_nodes.begin(); iter != level_nodes.end(); ++iter) {
-                    visitor.do_required_traverse_node(tg, tc, dc, *iter);
-                }
-#elif defined(TATUM_USE_TBB)
+#if defined(TATUM_USE_TBB)
                 tbb::parallel_for_each(level_nodes.begin(), level_nodes.end(), [&](auto node) {
                     visitor.do_required_traverse_node(tg, tc, dc, node);
                 });
@@ -143,11 +105,7 @@ class ParallelLevelizedWalker : public TimingGraphWalker {
 
         void do_update_slack_impl(const TimingGraph& tg, const DelayCalculator& dc, GraphVisitor& visitor) override {
             auto nodes = tg.nodes();
-#if defined(TATUM_USE_CILK)
-            cilk_for(auto iter = nodes.begin(); iter != nodes.end(); ++iter) {
-                visitor.do_slack_traverse_node(tg, dc, *iter);
-            }
-#elif defined(TATUM_USE_TBB)
+#if defined(TATUM_USE_TBB)
             tbb::parallel_for_each(nodes.begin(), nodes.end(), [&](auto node) {
                 visitor.do_slack_traverse_node(tg, dc, node);
             });
@@ -161,14 +119,7 @@ class ParallelLevelizedWalker : public TimingGraphWalker {
         void do_reset_impl(const TimingGraph& tg, GraphVisitor& visitor) override {
             auto nodes = tg.nodes();
             auto edges = tg.edges();
-#if defined(TATUM_USE_CILK)
-            cilk_for(auto node_iter = nodes.begin(); node_iter != nodes.end(); ++node_iter) {
-                visitor.do_reset_node(*node_iter);
-            }
-            cilk_for(auto edge_iter = edges.begin(); edge_iter != edges.end(); ++edge_iter) {
-                visitor.do_reset_edge(*edge_iter);
-            }
-#elif defined(TATUM_USE_TBB)
+#if defined(TATUM_USE_TBB)
             tbb::parallel_for_each(nodes.begin(), nodes.end(), [&](auto node) {
                 visitor.do_reset_node(node);
             });

libtatum/tatum/graph_walkers/ParallelWalker.hpp

@@ -1,6 +1,5 @@
 #pragma once
 
-//ParallelWalker is an alias for ParallelLevelizedCilkWalker 
 #include "tatum/graph_walkers_fwd.hpp"
 
 

tatum_test/main.cpp

@@ -32,9 +32,7 @@
 #include "util.hpp"
 #include "profile.hpp"
 
-#if defined(TATUM_USE_CILK) 
-# include <cilk/cilk_api.h>
-#elif defined(TATUM_USE_TBB) 
+#if defined(TATUM_USE_TBB) 
 # include <tbb/task_scheduler_init.h>
 #endif
 typedef std::chrono::duration<double> dsec;
@@ -256,16 +254,7 @@ int main(int argc, char** argv) {
         cout << "NodeType class alignof = " << alignof(tatum::NodeType) << " bytes." << endl;
     }
 
-#if defined(TATUM_USE_CILK)
-    size_t actual_num_workers = args.num_workers;
-    if (actual_num_workers == 0) {
-        actual_num_workers = __cilkrts_get_nworkers();
-    }
-    if (__cilkrts_set_param("nworkers", std::to_string(actual_num_workers).c_str()) != 0) {
-        exit(1);
-    }
-    cout << "Tatum executing with up to " << actual_num_workers << " workers via cilk\n";
-#elif defined(TATUM_USE_TBB) 
+#if defined(TATUM_USE_TBB) 
     size_t actual_num_workers = args.num_workers;
     if (actual_num_workers == 0) {
         actual_num_workers = tbb::task_scheduler_init::default_num_threads();