Simplify wait_for posix

Author: pippocao

src/bq_common/platform/thread/condition_variable_posix.cpp

@@ -64,92 +64,70 @@ namespace bq {
             free(platform_data_);
             platform_data_ = nullptr;
         }
-        static constexpr uint64_t one_billion = 1000000000ULL;
-
-        void condition_variable::wait(bq::platform::mutex& lock)
+        
+        static uint64_t get_current_ns(bool use_monotonic)
         {
-            int32_t result = pthread_cond_wait(&platform_data_->cond_handle, (pthread_mutex_t*)(lock.get_platform_handle()));
-            if (result != 0) {
-                bq::util::log_device_console(log_level::error, "pthread_cond_wait failed: %d", result);
-            }
-        }
-
-        static inline void add_timespec_ns(const struct timespec& base, uint64_t add_ns, struct timespec* out)
-        {
-            uint64_t ns = static_cast<uint64_t>(base.tv_nsec) + add_ns;
-            out->tv_sec = static_cast<decltype(out->tv_sec)>(static_cast<int64_t>(base.tv_sec) + static_cast<int64_t>(ns / one_billion));
-            out->tv_nsec = static_cast<decltype(out->tv_nsec)>(ns % one_billion);
-        }
-
-        static uint64_t get_current_ns(bool prefer_monotonic)
-        {
-            struct timespec ts {};
+            struct timespec ts;
 #if defined(BQ_POSIX_MONOTONIC_SUPPORTED)
-            if (prefer_monotonic) {
+            if (use_monotonic) {
                 if (clock_gettime(CLOCK_MONOTONIC, &ts) == 0) {
-                    return static_cast<uint64_t>(ts.tv_sec) * one_billion + static_cast<uint64_t>(ts.tv_nsec);
+                    return static_cast<uint64_t>(ts.tv_sec) * 1000000000ULL + static_cast<uint64_t>(ts.tv_nsec);
                 }
             }
 #endif
-            (void)prefer_monotonic;
             if (clock_gettime(CLOCK_REALTIME, &ts) == 0) {
-                return static_cast<uint64_t>(ts.tv_sec) * one_billion + static_cast<uint64_t>(ts.tv_nsec);
+                return static_cast<uint64_t>(ts.tv_sec) * 1000000000ULL + static_cast<uint64_t>(ts.tv_nsec);
             }
             return bq::platform::high_performance_epoch_ms() * 1000000ULL;
         }
 
+        void condition_variable::wait(bq::platform::mutex& lock)
+        {
+            int32_t result = pthread_cond_wait(&platform_data_->cond_handle, (pthread_mutex_t*)(lock.get_platform_handle()));
+            if (result != 0) {
+                bq::util::log_device_console(log_level::error, "pthread_cond_wait failed: %d", result);
+            }
+        }
+
         bool condition_variable::wait_for(bq::platform::mutex& lock, uint64_t wait_time_ms)
         {
             const uint64_t wait_ns_total = wait_time_ms * 1000000ULL;
-            const uint64_t quantum_ns = 50ULL * 1000000ULL; // 50ms
+            const uint64_t quantum_ns = 50ULL * 1000000ULL; // 50ms slice
             const bool use_monotonic = platform_data_->use_monotonic_clock;
 
             uint64_t start_ns = get_current_ns(use_monotonic);
             uint64_t deadline_ns = start_ns + wait_ns_total;
+            uint64_t next_slice_ns = start_ns + quantum_ns;
 
-            for (;;) {
+            while (true) {
                 uint64_t now_ns = get_current_ns(use_monotonic);
-
-                if (now_ns >= deadline_ns)
+                if (now_ns >= deadline_ns) {
                     return false;
+                }
 
-                uint64_t remain_ns = deadline_ns - now_ns;
-                if (remain_ns > quantum_ns)
-                    remain_ns = quantum_ns;
+                if (now_ns >= next_slice_ns) {
+                    uint64_t elapsed = now_ns - start_ns;
+                    uint64_t next_slice_idx = (elapsed / quantum_ns) + 1;
+                    next_slice_ns = start_ns + next_slice_idx * quantum_ns;
+                }
 
-                struct timespec outtime {};
+                uint64_t target_ns = (deadline_ns < next_slice_ns) ? deadline_ns : next_slice_ns;
 
-#if defined(BQ_POSIX_MONOTONIC_SUPPORTED)
-                if (use_monotonic) {
-                    struct timespec now_mono {};
-                    if (clock_gettime(CLOCK_MONOTONIC, &now_mono) != 0) {
-                        now_mono.tv_sec = static_cast<decltype(now_mono.tv_sec)>(now_ns / one_billion);
-                        now_mono.tv_nsec = static_cast<decltype(now_mono.tv_nsec)>(now_ns % one_billion);
-                    }
-                    add_timespec_ns(now_mono, remain_ns, &outtime);
-                } else
-#endif
-                {
-                    struct timespec now_rt {};
-                    if (clock_gettime(CLOCK_REALTIME, &now_rt) != 0) {
-                        struct timeval tv {};
-                        gettimeofday(&tv, nullptr);
-                        now_rt.tv_sec = static_cast<decltype(now_rt.tv_sec)>(tv.tv_sec);
-                        now_rt.tv_nsec = static_cast<decltype(now_rt.tv_nsec)>(tv.tv_usec * 1000L);
-                    }
-                    add_timespec_ns(now_rt, remain_ns, &outtime);
-                }
+                struct timespec ts;
+                ts.tv_sec = static_cast<time_t>(target_ns / 1000000000ULL);
+                ts.tv_nsec = static_cast<long>(target_ns % 1000000000ULL);
 
                 int32_t result = pthread_cond_timedwait(&platform_data_->cond_handle,
                     (pthread_mutex_t*)(lock.get_platform_handle()),
-                    &outtime);
+                    &ts);
+
                 if (result == 0)
                     return true;
-                if (result == ETIMEDOUT)
-                    continue;
-
-                bq::util::log_device_console(log_level::error, "pthread_cond_timedwait failed: %d", result);
-                return true;
+                
+                if (result != ETIMEDOUT) {
+                    bq::util::log_device_console(log_level::error, "pthread_cond_timedwait failed: %d", result);
+                    return true;
+                }
             }
         }