Adjust the try_lock_until algorithm to match the wording in P3832R2

Since a timed lockable's try_lock_until will not return failure in case
the time given has already expired, but instead return this->try_lock(),
there was a theoretical possibility of never getting out of the loop.

It was essentially possible to get into this situation:
  m1.try_lock_until(expired_tp); // succeeds
  m2.try_lock();                 // fails
  m2.try_lock_until(expired_tp); // succeeds
  m1.try_lock();                 // fails
  // back to the original situation and it could keep going

The remedy was to add wording about "the above steps are repeated until
the time point abs_time has been reached" which made it necessary to do
a Clock::now() call before trying a new sequence (sorry Bosse).

Signed-off-by: Ted Lyngmo <ted@lyncon.se>

Author: TedLyngmo

include/beman/timed_lock_alg/mutex.hpp

@@ -67,11 +67,11 @@ struct result {
     bool retry;
 };
 //-------------------------------------------------------------------------
-template <class Timepoint, class Locks, class... Seqs>
-int try_lock_until_impl(const Timepoint& end_time, Locks locks, type_pack<Seqs...>) {
+template <class Clock, class Duration, class Locks, class... Seqs>
+int try_lock_until_impl(const std::chrono::time_point<Clock, Duration>& end_time, Locks locks, type_pack<Seqs...>) {
     // an array with one function per lockable/sequence to try:
-    constexpr std::array<result (*)(const Timepoint&, Locks&), sizeof...(Seqs)> seqs{
-        {+[](const Timepoint& tp, Locks& lks) {
+    constexpr std::array<result (*)(const std::chrono::time_point<Clock, Duration>&, Locks&), sizeof...(Seqs)> seqs{
+        {+[](const std::chrono::time_point<Clock, Duration>& tp, Locks& lks) {
             return []<class Tp, std::size_t I0, std::size_t... Is>(
                        const Tp& itp, Locks& lcks, std::index_sequence<I0, Is...>) -> result {
                 if (std::unique_lock first{std::get<I0>(lcks), itp}) {
@@ -80,9 +80,10 @@ int try_lock_until_impl(const Timepoint& end_time, Locks locks, type_pack<Seqs..
                         first.release();
                         return {-1, false}; // success
                     }
-                    // return the index to try_lock_until next round
+                    // return the index to try_lock_until next round or the index which failed to lock
+                    // in case time has run out
                     constexpr std::array idxs{static_cast<int>(Is)...};
-                    return {idxs[static_cast<std::size_t>(res)], true};
+                    return {idxs[static_cast<std::size_t>(res)], Clock::now() < itp};
                 }
                 // timeout
                 return {static_cast<int>(I0), false};

tests/beman/timed_lock_alg/try_lock.test.cpp

@@ -229,5 +229,5 @@ TEST(TryLockIntegration, SucceedWithThreeInTrickySequence) {
         m0.should_fail = false; // unblock m0; try_lock(m1,m2) → both succeed → done
     });
 
-    EXPECT_EQ(-1, tla::try_lock_for(no_duration, m0, m1, m2));
+    EXPECT_EQ(-1, tla::try_lock_for(24h, m0, m1, m2));
 }