Update ICC module name on Piz Daint Jenkins configuration and fix ICC…

… compilation

.jenkins/cscs/ctest.cmake

@@ -17,6 +17,12 @@ set(CTEST_UPDATE_VERSION_ONLY "ON")
 set(CTEST_SUBMIT_RETRY_COUNT 5)
 set(CTEST_SUBMIT_RETRY_DELAY 60)
 
+# We reduce the number of concurrent jobs with icc since it has higher memory
+# requirements than other compilers.
+if("${CTEST_BUILD_CONFIGURATION_NAME}" STREQUAL "icc")
+  set(CTEST_BUILD_PARALLELISM 5)
+endif()
+
 if(NOT "$ENV{ghprbPullId}" STREQUAL "")
   set(CTEST_BUILD_NAME "$ENV{ghprbPullId}-${CTEST_BUILD_CONFIGURATION_NAME}")
   set(CTEST_TRACK "Pull_Requests")

.jenkins/cscs/entry.sh

@@ -34,7 +34,7 @@ sbatch \
     --constraint="${configuration_slurm_constraint}" \
     --partition="cscsci" \
     --account="djenkssl" \
-    --time="01:30:00" \
+    --time="03:00:00" \
     --output="jenkins-hpx-${configuration_name}.out" \
     --error="jenkins-hpx-${configuration_name}.err" \
     --wait .jenkins/cscs/batch.sh

.jenkins/cscs/env-icc.sh

@@ -19,6 +19,7 @@ export CXX=`which CC`
 export CC=`which cc`
 
 configure_extra_options="-DCMAKE_BUILD_TYPE=Debug"
+configure_extra_options+=" -DHPX_WITH_NETWORKING=OFF"
 configure_extra_options+=" -DHPX_WITH_MAX_CPU_COUNT=128"
 configure_extra_options+=" -DHPX_WITH_MALLOC=system"
 configure_extra_options+=" -DHPX_WITH_COMPILER_WARNINGS=ON"

CMakeLists.txt

@@ -2069,6 +2069,8 @@ else()
     hpx_add_compile_flag_if_available(-wd2203)
     # #2536: cannot specify explicit initializer for arrays
     hpx_add_compile_flag_if_available(-wd2536)
+    # #1286: invalid attribute
+    hpx_add_compile_flag_if_available(-wd1286)
   endif()
 
   set(__has_timestamp_support OFF)

hpx/plugins/parcelport/tcp/receiver.hpp

@@ -320,7 +320,8 @@ namespace hpx { namespace parcelset { namespace policies { namespace tcp
                     = &receiver::handle_write_ack<Handler>;
 
                 // decode the received parcels.
-                decode_parcels(parcelport_, std::move(buffer_), -1);
+                decode_parcels(
+                    parcelport_, std::move(buffer_), std::size_t(-1));
                 buffer_ = parcel_buffer_type();
 
                 ack_ = true;

libs/core/config/include/hpx/config/attributes.hpp

@@ -63,7 +63,7 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 // handle [[deprecated]]
-#if HPX_HAVE_DEPRECATION_WARNINGS
+#if HPX_HAVE_DEPRECATION_WARNINGS && !defined(HPX_INTEL_VERSION)
 #  define HPX_DEPRECATED_MSG \
    "This functionality is deprecated and will be removed in the future."
 #  define HPX_DEPRECATED(x) [[deprecated(x)]]

libs/core/config/include/hpx/config/compiler_fence.hpp

@@ -21,6 +21,8 @@
 #else
 #if defined(__INTEL_COMPILER)
 
+#include <immintrin.h>
+#define HPX_SMT_PAUSE _mm_pause()
 #define HPX_COMPILER_FENCE __memory_barrier()
 
 #elif defined(_MSC_VER) && _MSC_VER >= 1310

libs/core/format/include/hpx/util/from_string.hpp

@@ -38,8 +38,15 @@ namespace hpx { namespace util {
         {
             U const min = (std::numeric_limits<T>::min)();
             U const max = (std::numeric_limits<T>::max)();
+#if defined(HPX_INTEL_VERSION)
+#pragma warning(push)
+#pragma warning(disable : 186)
+#endif
             if (value < min || value > max)
                 throw std::out_of_range("from_string: out of range");
+#if defined(HPX_INTEL_VERSION)
+#pragma warning(pop)
+#endif
             return static_cast<T>(value);
         }
 

libs/core/functional/src/basic_function.cpp

@@ -66,7 +66,8 @@ namespace hpx { namespace util { namespace detail {
             {
                 HPX_ASSERT(other.object != nullptr);
                 // reuse object storage
-                object = vptr->copy(object, -1, other.object, /*destroy*/ true);
+                object = vptr->copy(
+                    object, std::size_t(-1), other.object, /*destroy*/ true);
             }
         }
         else

libs/core/thread_pools/src/scheduled_thread_pool.cpp

@@ -4,34 +4,35 @@
 //  Distributed under the Boost Software License, Version 1.0. (See accompanying
 //  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
+#include <hpx/config.hpp>
+#include <hpx/schedulers/local_priority_queue_scheduler.hpp>
+#include <hpx/schedulers/local_queue_scheduler.hpp>
+#include <hpx/schedulers/shared_priority_queue_scheduler.hpp>
+#include <hpx/schedulers/static_priority_queue_scheduler.hpp>
+#include <hpx/schedulers/static_queue_scheduler.hpp>
 #include <hpx/thread_pools/scheduled_thread_pool.hpp>
 #include <hpx/thread_pools/scheduled_thread_pool_impl.hpp>
 
 ///////////////////////////////////////////////////////////////////////////////
 /// explicit template instantiation for the thread pools of our choice
-#include <hpx/schedulers/local_queue_scheduler.hpp>
 template class HPX_CORE_EXPORT hpx::threads::policies::local_queue_scheduler<>;
 template class HPX_CORE_EXPORT hpx::threads::detail::scheduled_thread_pool<
     hpx::threads::policies::local_queue_scheduler<>>;
 
-#include <hpx/schedulers/static_queue_scheduler.hpp>
 template class HPX_CORE_EXPORT hpx::threads::policies::static_queue_scheduler<>;
 template class HPX_CORE_EXPORT hpx::threads::detail::scheduled_thread_pool<
     hpx::threads::policies::static_queue_scheduler<>>;
 
-#include <hpx/schedulers/static_priority_queue_scheduler.hpp>
 template class HPX_CORE_EXPORT
-    hpx::threads::policies::static_priority_queue_scheduler<>;
+    hpx::threads::policies::local_priority_queue_scheduler<>;
 template class HPX_CORE_EXPORT hpx::threads::detail::scheduled_thread_pool<
-    hpx::threads::policies::static_priority_queue_scheduler<>>;
+    hpx::threads::policies::local_priority_queue_scheduler<std::mutex,
+        hpx::threads::policies::lockfree_fifo>>;
 
-#include <hpx/schedulers/local_priority_queue_scheduler.hpp>
 template class HPX_CORE_EXPORT
-    hpx::threads::policies::local_priority_queue_scheduler<std::mutex,
-        hpx::threads::policies::lockfree_fifo>;
+    hpx::threads::policies::static_priority_queue_scheduler<>;
 template class HPX_CORE_EXPORT hpx::threads::detail::scheduled_thread_pool<
-    hpx::threads::policies::local_priority_queue_scheduler<std::mutex,
-        hpx::threads::policies::lockfree_fifo>>;
+    hpx::threads::policies::static_priority_queue_scheduler<>>;
 #if defined(HPX_HAVE_CXX11_STD_ATOMIC_128BIT)
 template class HPX_CORE_EXPORT
     hpx::threads::policies::local_priority_queue_scheduler<std::mutex,
@@ -56,7 +57,6 @@ template class HPX_CORE_EXPORT hpx::threads::detail::scheduled_thread_pool<
         hpx::threads::policies::lockfree_abp_lifo>>;
 #endif
 
-#include <hpx/schedulers/shared_priority_queue_scheduler.hpp>
 template class HPX_CORE_EXPORT
     hpx::threads::policies::shared_priority_queue_scheduler<>;
 template class HPX_CORE_EXPORT hpx::threads::detail::scheduled_thread_pool<

libs/full/batch_environments/src/batch_environment.cpp

@@ -27,9 +27,9 @@ namespace hpx { namespace util {
     batch_environment::batch_environment(std::vector<std::string>& nodelist,
         bool have_mpi, bool debug, bool enable)
       : agas_node_num_(0)
-      , node_num_(-1)
-      , num_threads_(-1)
-      , num_localities_(-1)
+      , node_num_(std::size_t(-1))
+      , num_threads_(std::size_t(-1))
+      , num_localities_(std::size_t(-1))
       , debug_(debug)
     {
         if (!enable)

libs/full/collectives/src/detail/barrier_node.cpp

@@ -56,7 +56,7 @@ namespace hpx { namespace lcos { namespace detail {
       , arity_(hpx::util::from_string<std::size_t>(
             get_config_entry("hpx.lcos.collectives.arity", 32)))
       , cut_off_(hpx::util::from_string<std::size_t>(
-            get_config_entry("hpx.lcos.collectives.cut_off", -1)))
+            get_config_entry("hpx.lcos.collectives.cut_off", std::size_t(-1))))
       , local_barrier_(num)
     {
         if (num_ >= cut_off_)

libs/full/performance_counters/tests/unit/all_counters.cpp

@@ -113,7 +113,7 @@ void test_all_locality_thread_counters(char const* const* counter_names,
             else
             {
                 path.subinstancename_ = "total";
-                path.subinstanceindex_ = std::size_t(-1);
+                path.subinstanceindex_ = -1;
             }
         }
         else if (core != std::size_t(-1))
@@ -124,7 +124,7 @@ void test_all_locality_thread_counters(char const* const* counter_names,
         else
         {
             path.instancename_ = "total";
-            path.instanceindex_ = std::size_t(-1);
+            path.instanceindex_ = -1;
         }
 
         std::string name;

libs/parallelism/algorithms/include/hpx/parallel/algorithms/for_loop.hpp

@@ -1152,9 +1152,6 @@ namespace hpx {
                 ExPolicy&& policy, B first, Size size, S stride,
                 hpx::util::index_pack<Is...>, Args&&... args)
             {
-                // Size should be non-negative
-                HPX_ASSERT(size >= 0);
-
                 // stride shall not be zero
                 HPX_ASSERT(stride != 0);
 

libs/parallelism/async_combinators/include/hpx/async_combinators/wait_all.hpp

@@ -360,7 +360,11 @@ namespace hpx { namespace lcos {
     }
 
     template <typename Future>
-    HPX_FORCEINLINE void wait_all(std::vector<Future>&& values)
+#if !defined(HPX_INTEL_VERSION)
+    HPX_FORCEINLINE
+#endif
+        void
+        wait_all(std::vector<Future>&& values)
     {
         lcos::wait_all(const_cast<std::vector<Future> const&>(values));
     }

libs/parallelism/execution/include/hpx/execution/algorithms/detail/predicates.hpp

@@ -48,7 +48,14 @@ namespace hpx { namespace parallel { inline namespace v1 { namespace detail {
     HPX_HOST_DEVICE constexpr void advance_impl(
         InputIterator& i, Distance n, std::input_iterator_tag)
     {
+#if defined(HPX_INTEL_VERSION)
+#pragma warning(push)
+#pragma warning(disable : 186)
+#endif
         HPX_ASSERT(n >= 0);
+#if defined(HPX_INTEL_VERSION)
+#pragma warning(pop)
+#endif
         while (n--)
             ++i;
     }

libs/parallelism/execution/include/hpx/execution/executors/polymorphic_executor.hpp

@@ -212,6 +212,9 @@ namespace hpx { namespace parallel { namespace execution {
         HPX_NORETURN inline R throw_bad_polymorphic_executor()
         {
             throw_bad_polymorphic_executor();
+#if defined(HPX_INTEL_VERSION)
+            return {};
+#endif
         }
 
         ///////////////////////////////////////////////////////////////////////
@@ -350,6 +353,7 @@ namespace hpx { namespace parallel { namespace execution {
                 void*, sync_execute_function_type&&, Ts&&...)
             {
                 throw_bad_polymorphic_executor<R>();
+                return {};
             }
 
             constexpr oneway_vtable(
@@ -408,12 +412,14 @@ namespace hpx { namespace parallel { namespace execution {
                 async_execute_function_type&& /* f */, Ts&&... /* ts */)
             {
                 throw_bad_polymorphic_executor<R>();
+                return {};
             }
             static hpx::future<R> _empty_then_execute(void*,
                 then_execute_function_type&&, hpx::shared_future<void> const&,
                 Ts&&...)
             {
                 throw_bad_polymorphic_executor<R>();
+                return {};
             }
 
             constexpr twoway_vtable(
@@ -459,6 +465,7 @@ namespace hpx { namespace parallel { namespace execution {
                 bulk_sync_execute_function_type&&, range_proxy const&, Ts&&...)
             {
                 throw_bad_polymorphic_executor<R>();
+                return {};
             }
 
             constexpr bulk_oneway_vtable(
@@ -521,13 +528,15 @@ namespace hpx { namespace parallel { namespace execution {
                 bulk_async_execute_function_type&&, range_proxy const&, Ts&&...)
             {
                 throw_bad_polymorphic_executor<R>();
+                return {};
             }
 
             static hpx::future<std::vector<R>> _empty_bulk_then_execute(void*,
                 bulk_then_execute_function_type&&, range_proxy const&,
                 hpx::shared_future<void> const&, Ts&&...)
             {
                 throw_bad_polymorphic_executor<R>();
+                return {};
             }
 
             constexpr bulk_twoway_vtable(

libs/parallelism/execution/src/polymorphic_executor.cpp

@@ -70,7 +70,8 @@ namespace hpx { namespace parallel { namespace execution { namespace detail {
             {
                 // reuse object storage
                 HPX_ASSERT(other.object != nullptr);
-                object = vptr->copy(object, -1, other.object, true);
+                object =
+                    vptr->copy(object, std::size_t(-1), other.object, true);
             }
         }
         else

libs/parallelism/resiliency/examples/CMakeLists.txt

@@ -15,16 +15,18 @@ if(HPX_WITH_EXAMPLES)
     )
   endif()
 
-  set(example_programs
-      1d_stencil_replay_exception
-      1d_stencil_replay_validate
-      async_replay
-      async_replicate
-      async_replicate_vote
-      dataflow_replicate
-      version
+  set(example_programs async_replay async_replicate async_replicate_vote
+                       version
   )
 
+  # The Intel compiler version 19.1.1.217 does not manage to compile these.
+  # Other compilers have not been tested.
+  if(NOT "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Intel")
+    set(example_programs ${example_programs} 1d_stencil_replay_exception
+                         1d_stencil_replay_validate dataflow_replicate
+    )
+  endif()
+
   foreach(example_program ${example_programs})
 
     set(sources ${example_program}.cpp)

libs/parallelism/resiliency/tests/performance/replay/CMakeLists.txt

@@ -7,18 +7,18 @@
 # Distributed under the Boost Software License, Version 1.0. (See accompanying
 # file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
-set(benchmarks
-    1d_stencil
-    1d_stencil_replay
-    1d_stencil_checksum
-    async_replay
-    async_replay_validate
-    dataflow_replay
-    dataflow_replay_validate
-    pure_async_for_replay
-    pure_dataflow
+set(benchmarks 1d_stencil async_replay async_replay_validate
+               pure_async_for_replay pure_dataflow
 )
 
+# The Intel compiler version 19.1.1.217 does not manage to compile these. Other
+# versions have not been tested.
+if(NOT "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Intel")
+  list(APPEND benchmarks 1d_stencil_checksum 1d_stencil_replay dataflow_replay
+       dataflow_replay_validate
+  )
+endif()
+
 foreach(benchmark ${benchmarks})
 
   set(sources ${benchmark}.cpp)

libs/parallelism/resiliency/tests/performance/replicate/CMakeLists.txt

@@ -7,16 +7,16 @@
 # Distributed under the Boost Software License, Version 1.0. (See accompanying
 # file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
-set(benchmarks
-    1d_stencil_replicate
-    1d_stencil_replicate_checksum
-    async_replicate
-    async_replicate_validate
-    async_replicate_vote
-    async_replicate_vote_validate
-    pure_async_for_replicate
+set(benchmarks async_replicate async_replicate_validate async_replicate_vote
+               async_replicate_vote_validate pure_async_for_replicate
 )
 
+# The Intel compiler version 19.1.1.217 does not manage to compile these. Other
+# versions have not been tested.
+if(NOT "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Intel")
+  list(APPEND benchmarks 1d_stencil_replicate 1d_stencil_replicate_checksum)
+endif()
+
 foreach(benchmark ${benchmarks})
 
   set(sources ${benchmark}.cpp)

libs/parallelism/resiliency/tests/unit/CMakeLists.txt

@@ -11,14 +11,18 @@ set(tests
     async_replicate_plain
     async_replicate_vote_executor
     async_replicate_vote_plain
-    dataflow_replay_executor
-    dataflow_replay_plain
-    dataflow_replicate_executor
-    dataflow_replicate_plain
     replay_executor
     replicate_executor
 )
 
+# The Intel compiler version 19.1.1.217 does not manage to compile these. Other
+# versions have not been tested.
+if(NOT "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Intel")
+  list(APPEND tests dataflow_replay_executor dataflow_replay_plain
+       dataflow_replicate_executor dataflow_replicate_plain
+  )
+endif()
+
 foreach(test ${tests})
   set(sources ${test}.cpp)