devreal · therault · Oct 13, 2022 · Oct 14, 2022 · Oct 20, 2022 · Oct 20, 2022
diff --git a/.github/workflows/cmake.yml b/.github/workflows/cmake.yml
@@ -13,8 +13,10 @@ jobs:
         os : [ macos-latest, ubuntu-20.04 ]
         include:
           - os: ubuntu-20.04
-            cxx: /usr/bin/g++-9
+            cc: /usr/bin/gcc-10
+            cxx: /usr/bin/g++-10
           - os: macos-latest
+            cc: clang
             cxx: clang++
 
     name: "${{ matrix.os }}: ${{ matrix.cxx }} ${{ matrix.build_type }}"
@@ -36,6 +38,7 @@ jobs:
         -DMPIEXEC_PREFLAGS='--bind-to;none;--allow-run-as-root'
         -DCMAKE_INSTALL_PREFIX=${{github.workspace}}/install
         -DTTG_EXAMPLES=ON
+        -DCMAKE_CXX_STANDARD=20
 
     steps:
     - uses: actions/checkout@v2
@@ -50,7 +53,7 @@ jobs:
         wget -O - https://apt.kitware.com/keys/kitware-archive-latest.asc 2>/dev/null | gpg --dearmor - | sudo tee /etc/apt/trusted.gpg.d/kitware.gpg >/dev/null
         sudo apt-add-repository "deb https://apt.kitware.com/ubuntu/ $(lsb_release -cs) main"
         sudo apt-get update
-        sudo apt-get -y install ninja-build g++-9 liblapack-dev libboost-dev libboost-serialization-dev libeigen3-dev openmpi-bin libopenmpi-dev libtbb-dev ccache flex bison cmake
+        sudo apt-get -y install ninja-build g++-10 liblapack-dev libboost-dev libboost-serialization-dev libeigen3-dev openmpi-bin libopenmpi-dev libtbb-dev ccache flex bison cmake
 
     - name: Create Build Environment
       # Some projects don't allow in-source building, so create a separate build directory
@@ -99,7 +102,8 @@ jobs:
       # Note the current convention is to use the -S and -B options here to specify source 
       # and build directories, but this is only available with CMake 3.13 and higher.  
       # The CMake binaries on the Github Actions machines are (as of this writing) 3.12
-      run: cmake $GITHUB_WORKSPACE -DCMAKE_BUILD_TYPE=$BUILD_TYPE $BUILD_CONFIG
+      run: |
+        cmake $GITHUB_WORKSPACE -DCMAKE_BUILD_TYPE=$BUILD_TYPE $BUILD_CONFIG || (cat CMakeFiles/CMakeOutput.log && cat CMakeFiles/CMakeError.log)
 
     - name: Build
       working-directory: ${{github.workspace}}/build
@@ -124,7 +128,7 @@ jobs:
       working-directory: ${{github.workspace}}/build
       shell: bash
       run: |
-        cmake -S $GITHUB_WORKSPACE/doc/dox/dev/devsamp/main -B test_install_devsamp -DCMAKE_PREFIX_PATH=${{github.workspace}}/install
+        cmake -S $GITHUB_WORKSPACE/doc/dox/dev/devsamp/main -B test_install_devsamp -DCMAKE_PREFIX_PATH=${{github.workspace}}/install || (cat test_install_devsamp/CMakeFiles/CMakeOutput.log && cat test_install_devsamp/CMakeFiles/CMakeError.log)
         cmake --build test_install_devsamp
         cmake -E make_directory test_install_userexamples
         cat > test_install_userexamples/CMakeLists.txt <<EOF
@@ -136,7 +140,7 @@ jobs:
         add_ttg_executable(iterative $GITHUB_WORKSPACE/doc/dox/user/examples/iterative.cc NOT_EXCLUDE_FROM_ALL)
         add_ttg_executable(distributed $GITHUB_WORKSPACE/doc/dox/user/examples/distributed.cc NOT_EXCLUDE_FROM_ALL)
         EOF
-        cmake -S test_install_userexamples -B test_install_userexamples/build -DCMAKE_PREFIX_PATH=${{github.workspace}}/install
+        cmake -S test_install_userexamples -B test_install_userexamples/build -DCMAKE_PREFIX_PATH=${{github.workspace}}/install || (cat test_install_userexamples/CMakeFiles/CMakeOutput.log && cat test_install_userexamples/CMakeFiles/CMakeError.log)
         cmake --build test_install_userexamples/build
 
     - name: Build+Deploy Dox

diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -29,7 +29,12 @@ project(ttg
     LANGUAGES CXX
     HOMEPAGE_URL "https://tesseorg.github.io/ttg/")
 
-set(CMAKE_CXX_EXTENSIONS OFF)
+if (NOT DEFINED CMAKE_CXX_STANDARD)
+    set(CMAKE_CXX_STANDARD "20" CACHE STRING "The C++ standard")
+endif()
+if (NOT CMAKE_CXX_EXTENSIONS)
+  set(CMAKE_CXX_EXTENSIONS OFF CACHE BOOL "The C++ standard extensions allowed?")
+endif()
 
 list(APPEND CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake/modules/")
 include(GNUInstallDirs)
@@ -78,6 +83,28 @@ endif (BUILD_TESTING)
 include(FindOrFetchBoost)
 # Cereal
 #include(FindOrFetchCereal)
+# C++ coroutines
+find_package(CXXStdCoroutine MODULE REQUIRED COMPONENTS Final Experimental)
+
+##########################
+#### CUDA -- CUDA language must be added before PaRSEC detects CUDA
+##########################
+option(TTG_DISABLE_CUDA "True iff support for CUDA files is disabled, even if it is possible" OFF)
+if( NOT TTG_DISABLE_CUDA )
+  include(CheckLanguage)
+  check_language(CUDA)
+  if(CMAKE_CUDA_COMPILER)
+    enable_language(CUDA)
+  endif(CMAKE_CUDA_COMPILER)
+  set(TTG_HAVE_CUDA ${CMAKE_CUDA_COMPILER} CACHE BOOL "True if TTG supports compiling .cu files")
+  find_package(CUDAToolkit)
+  if (TARGET CUDA::cudart)
+    set(TTG_HAVE_CUDART True CACHE BOOL "True support for CUDART was found.")
+  endif(TARGET CUDA::cudart)
+else( NOT TTG_DISABLE_CUDA )
+  set(TTG_HAVE_CUDA OFF CACHE BOOL "Support for CUDA was disabled")
+  set(TTG_HAVE_CUDART OFF CACHE BOOL "Support for CUDA was disabled")
+endif( NOT TTG_DISABLE_CUDA )
 
 ##########################
 #### prerequisite runtimes
@@ -154,6 +181,7 @@ configure_package_config_file(cmake/ttg-config.cmake.in
 install(FILES
         "${PROJECT_SOURCE_DIR}/cmake/modules/AddTTGExecutable.cmake"
         "${PROJECT_SOURCE_DIR}/cmake/modules/AddTTGTestExecutable.cmake"
+        "${PROJECT_SOURCE_DIR}/cmake/modules/FindCXXStdCoroutine.cmake"
         DESTINATION "${CMAKE_INSTALL_CMAKEDIR}/modules"
         COMPONENT ttg-config)
 

diff --git a/cmake/modules/AddCUDAToolkit.cmake b/cmake/modules/AddCUDAToolkit.cmake
@@ -0,0 +1,9 @@
+find_package(CUDAToolkit)
+set(TTG_HAVE_CUDA ${CUDAToolkit_FOUND} CACHE BOOL "True if TTG supports CUDA")
+if (TTG_HAVE_CUDA)
+    check_language(CUDA)
+    if(CMAKE_CUDA_COMPILER)
+        enable_language(CUDA)
+    endif(CMAKE_CUDA_COMPILER)
+    set(TTG_HAVE_CU_COMPILER ${CMAKE_CUDA_COMPILER} CACHE BOOL "True if TTG supports compiling .cu files")
+endif(TTG_HAVE_CUDA)
diff --git a/cmake/modules/AddTTGLibrary.cmake b/cmake/modules/AddTTGLibrary.cmake
@@ -102,7 +102,14 @@ macro(add_ttg_library)
     # set_target_properties(${_library} PROPERTIES PUBLIC_HEADER "${ADD_TTG_LIBRARY_PUBLIC_HEADER}")
     # install manually
     foreach ( file ${ADD_TTG_LIBRARY_PUBLIC_HEADER} )
-        file(RELATIVE_PATH _rel_file_path "${PROJECT_SOURCE_DIR}/ttg" "${file}")
+        # N.B. some files are in the build tree
+        if ("${file}" MATCHES "^${PROJECT_SOURCE_DIR}/ttg")
+            file(RELATIVE_PATH _rel_file_path "${PROJECT_SOURCE_DIR}/ttg" "${file}")
+        elseif("${file}" MATCHES "^${PROJECT_BINARY_DIR}/ttg")
+            file(RELATIVE_PATH _rel_file_path "${PROJECT_BINARY_DIR}/ttg" "${file}")
+        else()
+            message(FATAL_ERROR "AddTTGLibrary: could not deduce install location for public header ${file} of component ${_library}")
+        endif()
         get_filename_component( dir "${_rel_file_path}" DIRECTORY )
         install( FILES ${file} DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/${dir}" COMPONENT ${_library})
     endforeach()

diff --git a/cmake/modules/ExternalDependenciesVersions.cmake b/cmake/modules/ExternalDependenciesVersions.cmake
@@ -6,5 +6,5 @@ set(TTG_TRACKED_BOOST_VERSION 1.66)
 set(TTG_TRACKED_CATCH2_VERSION 2.13.1)
 set(TTG_TRACKED_CEREAL_VERSION 1.3.0)
 set(TTG_TRACKED_MADNESS_TAG 687ac4f5308c82de04ea0f803f57417fa92713d5)
-set(TTG_TRACKED_PARSEC_TAG cb9322046c1f856fbca5804a9f96b83bbe2e676b)
+set(TTG_TRACKED_PARSEC_TAG 304e6f9d092e84fe58e6c7a8ea9d4e8b14794e5e) 
 set(TTG_TRACKED_BTAS_TAG ab866a760b72ff23053266bf46b87f19d3df44b7)
diff --git a/cmake/modules/FindCXXStdCoroutine.cmake b/cmake/modules/FindCXXStdCoroutine.cmake
@@ -0,0 +1,195 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+# This is copied from:
+#   https://github.com/vector-of-bool/CMakeCM/blob/master/modules/FindFilesystem.cmake
+
+#[=======================================================================[.rst:
+
+FindCXXStdCoroutine
+##############
+
+This module supports the C++20 standard library's coroutine utilities. Link your target to the
+:imp-target:`std::coroutine` imported target to provide standard C++ coroutine API.
+
+Options
+*******
+
+The ``COMPONENTS`` argument to this module supports the following values:
+
+.. find-component:: Experimental
+    :name: coro.Experimental
+
+    Allows the module to find the "experimental" version of the
+    Coroutine library. This is the library that should be used with the
+    ``std::experimental::coroutine`` namespace.
+
+.. find-component:: Final
+    :name: coro.Final
+
+    Finds the final C++20 standard version of the coroutine library.
+
+If no components are provided, behaves as if the
+:find-component:`coro.Final` component was specified.
+
+If both :find-component:`coro.Experimental` and :find-component:`coro.Final` are
+provided, first looks for ``Final``, and falls back to ``Experimental`` in case
+of failure. If ``Final`` is found, :imp-target:`std::coroutine` and all
+:ref:`variables <coro.variables>` will refer to the ``Final`` version.
+
+
+Imported Targets
+****************
+
+.. imp-target:: std::coroutine
+
+    The ``std::coroutine`` imported target is defined when any requested
+    version of the C++ coroutine library has been found, whether it is
+    *Experimental* or *Final*.
+
+    If no version of the coroutine library is available, this target will not
+    be defined.
+
+    .. note::
+        This target has ``cxx_std_20`` as an ``INTERFACE``
+        :ref:`compile language standard feature <req-lang-standards>`. Linking
+        to this target will automatically enable C++20 if no later standard
+        version is already required on the linking target.
+
+
+.. coro.variables:
+
+Variables
+*********
+
+.. variable:: CXX_COROUTINE_COMPONENT
+
+    Set to ``Final`` when the :find-component:`coro.Final` version of C++
+    coroutine library was found, ``Experimental`` when
+    the :find-component:`coro.Experimental` version of C++
+    coroutine library was found, otherwise not defined.
+
+.. variable:: CXX_COROUTINE_HAVE_CORO
+
+    Set to ``TRUE`` when a coroutine header was found.
+
+.. variable:: CXX_COROUTINE_HEADER
+
+    Set to either ``coroutine`` or ``experimental/coroutine`` depending on
+    whether :find-component:`coro.Final` or :find-component:`coro.Experimental` was
+    found.
+
+.. variable:: CXX_COROUTINE_NAMESPACE
+
+    Set to either ``std::coroutine`` or ``std::experimental::coroutine``
+    depending on whether :find-component:`coro.Final` or
+    :find-component:`coro.Experimental` was found.
+
+
+Examples
+********
+
+Using `find_package(Coroutine)` with no component arguments:
+
+.. code-block:: cmake
+
+    find_package(Coroutine REQUIRED)
+
+    add_executable(my-program main.cpp)
+    target_link_libraries(my-program PRIVATE std::coroutine)
+
+
+#]=======================================================================]
+
+
+if(TARGET std::coroutine)
+  # This module has already been processed. Don't do it again.
+  return()
+endif()
+
+include(CMakePushCheckState)
+include(CheckIncludeFileCXX)
+include(CheckCXXSourceCompiles)
+
+cmake_push_check_state()
+
+set(CMAKE_REQUIRED_QUIET ${CXXStdCoroutine_FIND_QUIETLY})
+
+# Normalize and check the component list we were given
+set(CXXStdCoroutines_want_components ${CXXStdCoroutine_FIND_COMPONENTS})
+if(CXXStdCoroutine_FIND_COMPONENTS STREQUAL "")
+  set(CXXStdCoroutines_want_components Final)
+endif()
+
+# Warn on any unrecognized components
+set(CXXStdCoroutines_extra_components ${CXXStdCoroutines_want_components})
+list(REMOVE_ITEM CXXStdCoroutines_extra_components Final Experimental)
+foreach(component IN LISTS CXXStdCoroutines_extra_components)
+  message(WARNING "Extraneous find_package component for CXXStdCoroutine: ${component}")
+endforeach()
+
+# clang may need to use -stdlib=c++ to have coroutines
+# gcc/libstdc++ needs -fcoroutines
+set(CXXStdCoroutines_find_options "" "-stdlib=libc++" "-fcoroutines")
+set(CXXStdCoroutines_std_options "" "-std=c++20" "-std=c++2a")
+set(CXXStdCoroutines_want_components_ordered "${CXXStdCoroutines_want_components}")
+list(SORT CXXStdCoroutines_want_components_ordered ORDER DESCENDING)  # Final before Experimental
+
+foreach(component IN LISTS CXXStdCoroutines_want_components_ordered)
+  if(component STREQUAL "Final")
+    set(_coro_header coroutine)
+    set(_coro_namespace std)
+  else()
+    set(_coro_header experimental/coroutine)
+    set(_coro_namespace std::experimental)
+  endif()
+  foreach(option IN LISTS CXXStdCoroutines_find_options)
+    foreach(stdoption IN LISTS CXXStdCoroutines_std_options)
+      cmake_push_check_state()
+      set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} ${option} ${stdoption}")
+
+      string(CONFIGURE [[
+        #include <@_coro_header@>
+
+        int main() {
+            auto x = @_coro_namespace@::suspend_always{};
+            return 0;
+        }
+      ]] code @ONLY)
+
+      check_cxx_source_compiles("${code}" HAVE_USABLE_${_coro_header})
+      mark_as_advanced(HAVE_USABLE_${_coro_header})
+      cmake_pop_check_state()
+      if(HAVE_USABLE_${_coro_header})
+        add_library(std::coroutine INTERFACE IMPORTED GLOBAL)
+        target_compile_features(std::coroutine INTERFACE cxx_std_20)
+        if (option)
+          target_compile_options(std::coroutine INTERFACE "${option}")
+        endif()
+        set(CXX_COROUTINE_COMPONENT "${component}" CACHE STRING "The component of CXXStdCoroutine package found")
+        # break out of this loop
+        break()
+      else()
+        unset(HAVE_USABLE_${_coro_header} CACHE)
+      endif()
+    endforeach()  # stdoption
+    if (TARGET std::coroutine)
+      break()
+    endif()
+  endforeach()  # option
+  if (TARGET std::coroutine)
+    break()
+  endif()
+endforeach() # components
+
+set(CXX_COROUTINE_HAVE_CORO ${HAVE_USABLE_${_coro_header}} CACHE BOOL "TRUE if we have usable C++ coroutine headers")
+set(CXX_COROUTINE_HEADER ${_coro_header} CACHE STRING "The header that should be included to obtain the coroutine APIs")
+set(CXX_COROUTINE_NAMESPACE ${_coro_namespace} CACHE STRING "The C++ namespace that contains the coroutine APIs")
+
+cmake_pop_check_state()
+
+set(CXXStdCoroutine_FOUND ${HAVE_USABLE_${_coro_header}} CACHE BOOL "TRUE if we have usable C++ coroutine headers" FORCE)
+
+if(CXXStdCoroutine_FIND_REQUIRED AND NOT TARGET std::coroutine)
+  message(FATAL_ERROR "Cannot discover std::coroutine headers and/or compile simple program using std::coroutine")
+endif()
diff --git a/cmake/modules/FindCXXStdExecution.cmake b/cmake/modules/FindCXXStdExecution.cmake
@@ -9,8 +9,8 @@
 FindCXXStdExecution
 ##############
 
-This module supports the C++17 standard library's execution utilities. Use the
-:imp-target:`std::execution` imported target to
+This module supports the C++17 standard library's execution utilities. Link your target to the
+:imp-target:`std::execution` imported target to provide standard C++ execution API.
 
 Imported Targets
 ****************
@@ -69,9 +69,6 @@ cmake_push_check_state()
 
 set(CMAKE_REQUIRED_QUIET ${CXXStdExecution_FIND_QUIETLY})
 
-# All of our tests required C++17 or later
-set(CMAKE_CXX_STANDARD 17)
-
 set(CXXStdExecution_FOUND FALSE)
 
 # We have execution header, but how do we use it? Do link checks
@@ -87,7 +84,7 @@ string(CONFIGURE [[
   }
   ]] code @ONLY)
 
-# Try to compile a simple filesystem program without any linker flags
+# Try to compile a simple execution program without any linker flags
 check_cxx_source_compiles("${code}" CXX_EXECUTION_NO_LINK_NEEDED)
 
 set(CXXStdExecution_CAN_LINK ${CXX_EXECUTION_NO_LINK_NEEDED})

diff --git a/cmake/modules/FindOrFetchPARSEC.cmake b/cmake/modules/FindOrFetchPARSEC.cmake
@@ -16,7 +16,7 @@ if (NOT TARGET PaRSEC::parsec)
 
   FetchContent_Declare(
           PARSEC
-          GIT_REPOSITORY      https://github.com/TESSEOrg/parsec.git
+          GIT_REPOSITORY      https://github.com/therault/parsec.git
           GIT_TAG             ${TTG_TRACKED_PARSEC_TAG}
   )
   FetchContent_MakeAvailable(PARSEC)