add some c++23 jobs to the CI job matrix (#1884)

ericniebler · web-flow · commit be07d47488b0 · 2026-02-23T10:43:22.000-08:00
diff --git a/.github/workflows/ci.cpu.yml b/.github/workflows/ci.cpu.yml
@@ -19,15 +19,17 @@ jobs:
       fail-fast: false
       matrix:
         include:
-          - { name: "CPU (clang 16, Debug)",         build: "Debug",   tag: llvm16-cuda12.9, cxxflags: "-stdlib=libc++" }
-          - { name: "CPU (clang 16, Release)",       build: "Release", tag: llvm16-cuda12.9, cxxflags: "-stdlib=libc++" }
-          - { name: "CPU (clang 16, Release, ASAN)", build: "Release", tag: llvm16-cuda12.9, cxxflags: "-stdlib=libc++ -fsanitize=address -fsanitize-ignorelist=/home/coder/stdexec/sanitizer-ignorelist.txt" }
-          - { name: "CPU (gcc 11, Debug)",           build: "Debug",   tag: gcc11-cuda12.9,  cxxflags: "", }
-          - { name: "CPU (gcc 11, Release)",         build: "Release", tag: gcc11-cuda12.9,  cxxflags: "", }
-          - { name: "CPU (gcc 11, Release, ASAN)",   build: "Release", tag: gcc11-cuda12.9,  cxxflags: "-fsanitize=address" }
-          - { name: "CPU (gcc 12, Release, TSAN)",   build: "Release", tag: gcc12-cuda12.9,  cxxflags: "-fsanitize=thread" }
-          - { name: "CPU (gcc 13, Debug)",           build: "Release", tag: gcc13-cuda12.9,  cxxflags: "", }
-          - { name: "CPU (gcc 14, Release, LEAK)",   build: "Release", tag: gcc14-cuda12.9,  cxxflags: "-fsanitize=leak", }
+          - { name: "CPU (clang 16, Debug)",         build: "Debug",   tag: llvm16-cuda12.9, cxxstd: "20", cxxflags: "-stdlib=libc++" }
+          - { name: "CPU (clang 16, Debug, c++23)",  build: "Debug",   tag: llvm16-cuda12.9, cxxstd: "23", cxxflags: "-stdlib=libc++" }
+          - { name: "CPU (clang 16, Release)",       build: "Release", tag: llvm16-cuda12.9, cxxstd: "20", cxxflags: "-stdlib=libc++" }
+          - { name: "CPU (clang 16, Release, ASAN)", build: "Release", tag: llvm16-cuda12.9, cxxstd: "20", cxxflags: "-stdlib=libc++ -fsanitize=address -fsanitize-ignorelist=/home/coder/stdexec/sanitizer-ignorelist.txt" }
+          - { name: "CPU (gcc 11, Debug)",           build: "Debug",   tag: gcc11-cuda12.9,  cxxstd: "20", cxxflags: "", }
+          - { name: "CPU (gcc 11, Release)",         build: "Release", tag: gcc11-cuda12.9,  cxxstd: "20", cxxflags: "", }
+          - { name: "CPU (gcc 11, Release, ASAN)",   build: "Release", tag: gcc11-cuda12.9,  cxxstd: "20", cxxflags: "-fsanitize=address" }
+          - { name: "CPU (gcc 12, Release, TSAN)",   build: "Release", tag: gcc12-cuda12.9,  cxxstd: "20", cxxflags: "-fsanitize=thread" }
+          - { name: "CPU (gcc 13, Debug)",           build: "Release", tag: gcc13-cuda12.9,  cxxstd: "20", cxxflags: "", }
+          - { name: "CPU (gcc 14, Release, LEAK)",   build: "Release", tag: gcc14-cuda12.9,  cxxstd: "20", cxxflags: "-fsanitize=leak", }
+          - { name: "CPU (gcc 14, Release, c++23)",  build: "Release", tag: gcc14-cuda12.9,  cxxstd: "23", cxxflags: "", }
     container:
       options: -u root
       image: rapidsai/devcontainers:26.02-cpp-${{ matrix.tag }}
@@ -100,6 +102,8 @@ jobs:
             -DSTDEXEC_ENABLE_TBB:BOOL=${{ !contains(matrix.cxxflags, '-fsanitize') }} \
             -DSTDEXEC_ENABLE_ASIO:BOOL=TRUE \
             -DSTDEXEC_ASIO_IMPLEMENTATION:STRING=boost \
+            -DCMAKE_CXX_STANDARD=${{ matrix.cxxstd }} \
+            -DCMAKE_CXX_EXTENSIONS=OFF \
             ;
 
           # Compile
diff --git a/include/exec/async_scope.hpp b/include/exec/async_scope.hpp
@@ -498,6 +498,7 @@ namespace experimental::execution
 
       ~__future_state_base()
       {
+        [[maybe_unused]]
         std::unique_lock __guard{__mutex_};
         if (__step_ == __future_step::__created)
         {
@@ -511,11 +512,12 @@ namespace experimental::execution
         }
       }
 
-      constexpr void __step_from_to_(std::unique_lock<std::mutex>& __guard,
-                                     __future_step                 __from,
-                                     __future_step                 __to)
+      constexpr void __step_from_to_([[maybe_unused]] std::unique_lock<std::mutex>& __guard,
+                                     [[maybe_unused]] __future_step                 __from,
+                                     __future_step                                  __to)
       {
         STDEXEC_ASSERT(__guard.owns_lock());
+        [[maybe_unused]]
         auto actual = std::exchange(__step_, __to);
         STDEXEC_ASSERT(actual == __from);
       }
diff --git a/include/exec/linux/io_uring_context.hpp b/include/exec/linux/io_uring_context.hpp
@@ -22,6 +22,7 @@
 #  include <linux/io_uring.h>
 
 #  include "../../stdexec/__detail/__atomic.hpp"
+#  include "../../stdexec/__detail/__utility.hpp"
 #  include "../../stdexec/execution.hpp"
 #  include "../timed_scheduler.hpp"
 
@@ -1109,7 +1110,9 @@ namespace experimental::execution
         auto secs = std::chrono::duration_cast<std::chrono::seconds>(dur);
         dur -= secs;
         secs = (std::max) (secs, std::chrono::seconds{0});
-        dur  = std::clamp(dur, std::chrono::nanoseconds{0}, std::chrono::nanoseconds{999'999'999});
+        dur  = STDEXEC::__clamp(dur,
+                               std::chrono::nanoseconds{0},
+                               std::chrono::nanoseconds{999'999'999});
         return __kernel_timespec{secs.count(), dur.count()};
       }
 #    else
@@ -1125,9 +1128,9 @@ namespace experimental::execution
         __nsec     = std::chrono::nanoseconds{__timerspec.it_value.tv_nsec} + __nsec;
         auto __sec = std::chrono::duration_cast<std::chrono::seconds>(__nsec);
         __nsec -= __sec;
-        __nsec = std::clamp(__nsec,
-                            std::chrono::nanoseconds{0},
-                            std::chrono::nanoseconds{999'999'999});
+        __nsec = STDEXEC::__clamp(__nsec,
+                                  std::chrono::nanoseconds{0},
+                                  std::chrono::nanoseconds{999'999'999});
         __timerspec.it_value.tv_sec += __sec.count();
         __timerspec.it_value.tv_nsec = __nsec.count();
         STDEXEC_ASSERT(0 <= __timerspec.it_value.tv_nsec
diff --git a/include/stdexec/__detail/__any.hpp b/include/stdexec/__detail/__any.hpp
@@ -32,6 +32,9 @@
 #include <type_traits>
 #include <utility>
 
+STDEXEC_PRAGMA_PUSH()
+STDEXEC_PRAGMA_IGNORE_GNU("-Wredundant-consteval-if")
+
 namespace STDEXEC::__any
 {
 
@@ -1698,10 +1701,9 @@ namespace STDEXEC::__any
       if (__empty(__other))
       {
         return;
-        // NOLINTNEXTLINE(bugprone-branch-clone)
       }
       else if constexpr (_Other::__root_kind == __root_kind::__reference || !__ptr_convertible)
-      {
+      {  // NOLINT(bugprone-branch-clone)
         return __other.__slice_to_(*this);
       }
       else if (__other.__in_situ_())
@@ -2012,3 +2014,5 @@ namespace STDEXEC::__any
   };
 
 }  // namespace STDEXEC::__any
+
+STDEXEC_PRAGMA_POP()
diff --git a/include/stdexec/__detail/__config.hpp b/include/stdexec/__detail/__config.hpp
@@ -612,7 +612,7 @@ namespace STDEXEC
 
 #define STDEXEC_ASSERT(_XP)                                                                        \
   do {                                                                                             \
-    static_assert(noexcept(_XP));                                                                  \
+    /*static_assert(noexcept(_XP));*/                                                              \
     STDEXEC_ASSERT_FN(_XP);                                                                        \
   } while (false)
 
diff --git a/include/stdexec/__detail/__task.hpp b/include/stdexec/__detail/__task.hpp
@@ -103,7 +103,8 @@ namespace STDEXEC
         // promise object. We now use that allocator to deallocate the entire block of
         // memory:
         size_t const __promise_blocks = __task::__divmod(__bytes, sizeof(__memblock));
-        void* const  __alloc_loc      = static_cast<__memblock*>(__ptr) + __promise_blocks;
+        [[maybe_unused]]
+        void* const __alloc_loc = static_cast<__memblock*>(__ptr) + __promise_blocks;
         // the number of blocks needed to store an object of type __palloc_t:
         static constexpr size_t __alloc_blocks =
           __task::__divmod(sizeof(__task::__any_alloc<_PAlloc>), sizeof(__task::__memblock));
diff --git a/include/stdexec/__detail/__utility.hpp b/include/stdexec/__detail/__utility.hpp
@@ -196,6 +196,13 @@ namespace STDEXEC
     return static_cast<__copy_cvref_t<_Ty&&, STDEXEC_REMOVE_REFERENCE(_Uy)>>(__uy);
   }
 
+  template <class _Ty>
+  constexpr _Ty const & __clamp(_Ty const & v, _Ty const & lo, _Ty const & hi)
+  {
+    STDEXEC_ASSERT(!(hi < lo));
+    return v < lo ? lo : hi < v ? hi : v;  // NOLINT(bugprone-return-const-ref-from-parameter)
+  }
+
   STDEXEC_PRAGMA_PUSH()
   STDEXEC_PRAGMA_IGNORE_GNU("-Wold-style-cast")
 

Original file line number	Diff line number	Diff line change
`@@ -498,6 +498,7 @@ namespace experimental::execution`
`498`	`498`
`499`	`499`	`~__future_state_base()`
`500`	`500`	`{`
	`501`	`+ [[maybe_unused]]`
`501`	`502`	`std::unique_lock __guard{__mutex_};`
`502`	`503`	`if (__step_ == __future_step::__created)`
`503`	`504`	`{`
`@@ -511,11 +512,12 @@ namespace experimental::execution`
`511`	`512`	`}`
`512`	`513`	`}`
`513`	`514`
`514`		`- constexpr void __step_from_to_(std::unique_lock<std::mutex>& __guard,`
`515`		`- __future_step __from,`
`516`		`- __future_step __to)`
	`515`	`+ constexpr void __step_from_to_([[maybe_unused]] std::unique_lock<std::mutex>& __guard,`
	`516`	`+ [[maybe_unused]] __future_step __from,`
	`517`	`+ __future_step __to)`
`517`	`518`	`{`
`518`	`519`	`STDEXEC_ASSERT(__guard.owns_lock());`
	`520`	`+ [[maybe_unused]]`
`519`	`521`	`auto actual = std::exchange(__step_, __to);`
`520`	`522`	`STDEXEC_ASSERT(actual == __from);`
`521`	`523`	`}`
Original file line number	Diff line number	Diff line change
`@@ -32,6 +32,9 @@`
`32`	`32`	`#include <type_traits>`
`33`	`33`	`#include <utility>`
`34`	`34`
	`35`	`+STDEXEC_PRAGMA_PUSH()`
	`36`	`+STDEXEC_PRAGMA_IGNORE_GNU("-Wredundant-consteval-if")`
	`37`	`+`
`35`	`38`	`namespace STDEXEC::__any`
`36`	`39`	`{`
`37`	`40`
`@@ -1698,10 +1701,9 @@ namespace STDEXEC::__any`
`1698`	`1701`	`if (__empty(__other))`
`1699`	`1702`	`{`
`1700`	`1703`	`return;`
`1701`		`- // NOLINTNEXTLINE(bugprone-branch-clone)`
`1702`	`1704`	`}`
`1703`	`1705`	`else if constexpr (_Other::__root_kind == __root_kind::__reference \|\| !__ptr_convertible)`
`1704`		`- {`
	`1706`	`+ { // NOLINT(bugprone-branch-clone)`
`1705`	`1707`	`return __other.__slice_to_(*this);`
`1706`	`1708`	`}`
`1707`	`1709`	`else if (__other.__in_situ_())`
`@@ -2012,3 +2014,5 @@ namespace STDEXEC::__any`
`2012`	`2014`	`};`
`2013`	`2015`
`2014`	`2016`	`} // namespace STDEXEC::__any`
	`2017`	`+`
	`2018`	`+STDEXEC_PRAGMA_POP()`