sys/cpp11-compat: Use ztimer64_usec instead of xtimer

sys/Makefile.dep

@@ -417,7 +417,7 @@ endif
 
 ifneq (,$(filter cpp11-compat,$(USEMODULE)))
   USEMODULE += cpp_new_delete
-  USEMODULE += xtimer
+  USEMODULE += ztimer64_usec
   USEMODULE += timex
   FEATURES_REQUIRED += cpp
   FEATURES_REQUIRED += libstdcpp

sys/cpp11-compat/Kconfig

@@ -15,6 +15,5 @@ config MODULE_CPP11-COMPAT
     select MODULE_CPP
     select MODULE_LIBSTDCPP
     select MODULE_CPP_NEW_DELETE
-    select MODULE_XTIMER
+    select ZTIMER64_USEC
     select MODULE_TIMEX
-    select MODULE_ZTIMER64_XTIMER_COMPAT if MODULE_ZTIMER_XTIMER_COMPAT

sys/cpp11-compat/condition_variable.cpp

@@ -24,8 +24,8 @@
 #include "irq.h"
 #include "sched.h"
 #include "thread.h"
-#include "timex.h"
-#include "xtimer.h"
+#include "time_units.h"
+#include "ztimer64.h"
 #include "priority_queue.h"
 
 #include "riot/condition_variable.hpp"
@@ -99,18 +99,19 @@ void condition_variable::wait(unique_lock<mutex>& lock) noexcept {
 
 cv_status condition_variable::wait_until(unique_lock<mutex>& lock,
                                          const time_point& timeout_time) {
-  xtimer_t timer;
-  // todo: use function to wait for absolute timepoint once available
-  timex_t before;
-  xtimer_now_timex(&before);
-  auto diff = timex_sub(timeout_time.native_handle(), before);
-  xtimer_set_wakeup(&timer, timex_uint64(diff), thread_getpid());
+  ztimer64_t timer;
+  uint64_t total_timeout_time_us = timeout_time.microseconds();
+  total_timeout_time_us += timeout_time.seconds() * US_PER_SEC;
+
+  ztimer64_set_wakeup_at(ZTIMER64_USEC, &timer, total_timeout_time_us,
+                         thread_getpid());
   wait(lock);
-  timex_t after;
-  xtimer_now_timex(&after);
-  xtimer_remove(&timer);
-  auto cmp = timex_cmp(after, timeout_time.native_handle());
-  return cmp < 1 ? cv_status::no_timeout : cv_status::timeout;
+  if (ztimer64_now(ZTIMER64_USEC) >= total_timeout_time_us) {
+    ztimer64_remove(ZTIMER64_USEC, &timer);
+    return cv_status::timeout;
+  }
+  ztimer64_remove(ZTIMER64_USEC, &timer);
+  return cv_status::no_timeout;
 }
 
 } // namespace riot

sys/cpp11-compat/include/riot/chrono.hpp

@@ -12,7 +12,7 @@
  *
  * @file
  * @brief  C++11 chrono drop in replacement that adds the function now based on
- *         xtimer/timex
+ *         ztimer/timex
  * @see    <a href="http://en.cppreference.com/w/cpp/thread/thread">
  *           std::thread, defined in header thread
  *         </a>
@@ -29,7 +29,8 @@
 #include <algorithm>
 
 #include "time.h"
-#include "xtimer.h"
+#include "timex.h"
+#include "ztimer64.h"
 
 namespace riot {
 
@@ -106,7 +107,7 @@ class time_point {
  */
 inline time_point now() {
   timex_t tp;
-  xtimer_now_timex(&tp);
+  tp = timex_from_uint64(ztimer64_now(ZTIMER64_USEC));
   return time_point(std::move(tp));
 }
 

sys/cpp11-compat/include/riot/condition_variable.hpp

@@ -25,7 +25,7 @@
 #define RIOT_CONDITION_VARIABLE_HPP
 
 #include "sched.h"
-#include "xtimer.h"
+#include "ztimer64.h"
 #include "priority_queue.h"
 
 #include "riot/mutex.hpp"
@@ -171,20 +171,18 @@ cv_status condition_variable::wait_for(unique_lock<mutex>& lock,
   if (timeout_duration <= timeout_duration.zero()) {
     return cv_status::timeout;
   }
-  timex_t timeout, before, after;
-  auto s = duration_cast<seconds>(timeout_duration);
-  timeout.seconds = s.count();
-  timeout.microseconds
-    = (duration_cast<microseconds>(timeout_duration - s)).count();
-  xtimer_now_timex(&before);
-  xtimer_t timer;
-  xtimer_set_wakeup(&timer, timex_uint64(timeout), thread_getpid());
+  uint64_t timeout, before, after;
+  timeout = (duration_cast<microseconds>(timeout_duration)).count();
+  before = ztimer64_now(ZTIMER64_USEC);
+  ztimer64_t timer;
+  ztimer64_set_wakeup(ZTIMER64_USEC, &timer, timeout, thread_getpid());
   wait(lock);
-  xtimer_now_timex(&after);
-  xtimer_remove(&timer);
-  auto passed = timex_sub(after, before);
-  auto cmp = timex_cmp(passed, timeout);
-  return cmp < 1 ? cv_status::no_timeout : cv_status::timeout;
+  after = ztimer64_now(ZTIMER64_USEC);
+  ztimer64_remove(ZTIMER64_USEC, &timer);
+  if (after - before >= timeout) {
+    return cv_status::timeout;
+  }
+  return cv_status::no_timeout;
 }
 
 template <class Rep, class Period, class Predicate>

sys/cpp11-compat/thread.cpp

@@ -17,12 +17,10 @@
  *
  * @}
  */
-
-#include "xtimer.h"
-
 #include <cerrno>
 #include <system_error>
 
+#include "ztimer64.h"
 #include "riot/thread.hpp"
 
 using namespace std;
@@ -73,7 +71,8 @@ namespace this_thread {
 void sleep_for(const chrono::nanoseconds& ns) {
   using namespace chrono;
   if (ns > nanoseconds::zero()) {
-    xtimer_usleep64(static_cast<uint64_t>(duration_cast<microseconds>(ns).count()));
+    ztimer64_sleep(ZTIMER64_USEC,
+        static_cast<uint64_t>(duration_cast<microseconds>(ns).count()));
   }
 }