sched/wdog: Refactor wdog module

This commit refactors the wdog module to use absolute time representation internally. The main improvements include:
1. Fixed recursive watchdog handling caused by calling wd_start within watchdog timeout callback function.
2. Simplified timer processing to improve performance and enhance code readability.
3. Improved accuracy of timers.
4. Reduced critical section and interrupt disable time, improving real-time performance.

Signed-off-by: ouyangxiangzhen <[email protected]>
Signed-off-by: ligd <[email protected]>

Author: Fix-Point

include/nuttx/clock.h

@@ -390,6 +390,47 @@ void clock_timespec_subtract(FAR const struct timespec *ts1,
                              FAR const struct timespec *ts2,
                              FAR struct timespec *ts3);
 
+/****************************************************************************
+ * Name: clock_compare
+ *
+ * Description:
+ *   This function is used for check whether the expired time is reached.
+ *   It take the ticks wrap-around into consideration.
+ *
+ * Input Parameters:
+ *   tick1 - Expected time in clock ticks
+ *   tick2 - Current time in clock ticks
+ *
+ * Returned Value:
+ *   true          - Expected ticks is timeout.
+ *   false         - Otherwise.
+ *
+ * Assumptions:
+ *   The type of delay value should be sclock_t.
+ *
+ ****************************************************************************/
+
+/* clock_compare considers tick wraparound, discussed as follows:
+ * Assuming clock_t is a 64-bit data type.
+ *
+ * Case 1: If tick2 - tick1 > 2^63, it is considered expired
+ *         or expired after tick2 wraparound.
+ *
+ * Case 2: If tick2 - tick1 <= 2^63,
+ *         it is considered not expired.
+ *
+ * For bit-63 as the sign bit, we can simplify this to:
+ * (sclock_t)(tick2 - tick1) >= 0.
+ *
+ * However, this function requires an assumption to work correctly:
+ * Assumes the timer delay time does not exceed SCLOCK_MAX (2^63 - 1).
+ *
+ * The range of the delay data type sclock_t being
+ * [- (SCLOCK_MAX + 1), SCLOCK_MAX] ensures this assumption holds.
+ */
+
+#define clock_compare(tick1, tick2) ((sclock_t)((tick2) - (tick1)) >= 0)
+
 /****************************************************************************
  * Name:  clock_isleapyear
  *

include/nuttx/wdog.h

@@ -83,7 +83,7 @@ struct wdog_s
 #ifdef CONFIG_PIC
   FAR void          *picbase;    /* PIC base address */
 #endif
-  sclock_t           lag;        /* Timer associated with the delay */
+  clock_t            expired;    /* Timer associated with the absoulute time */
 };
 
 /****************************************************************************
@@ -137,6 +137,45 @@ extern "C"
 int wd_start(FAR struct wdog_s *wdog, sclock_t delay,
              wdentry_t wdentry, wdparm_t arg);
 
+/****************************************************************************
+ * Name: wd_start_absolute
+ *
+ * Description:
+ *   This function adds a watchdog timer to the active timer queue.  The
+ *   specified watchdog function at 'wdentry' will be called from the
+ *   interrupt level after the specified number of ticks has reached.
+ *   Watchdog timers may be started from the interrupt level.
+ *
+ *   Watchdog timers execute in the address environment that was in effect
+ *   when wd_start() is called.
+ *
+ *   Watchdog timers execute only once.
+ *
+ *   To replace either the timeout delay or the function to be executed,
+ *   call wd_start again with the same wdog; only the most recent wdStart()
+ *   on a given watchdog ID has any effect.
+ *
+ * Input Parameters:
+ *   wdog     - Watchdog ID
+ *   ticks    - Absoulute time in clock ticks
+ *   wdentry  - Function to call on timeout
+ *   arg      - Parameter to pass to wdentry.
+ *
+ *   NOTE:  The parameter must be of type wdparm_t.
+ *
+ * Returned Value:
+ *   Zero (OK) is returned on success; a negated errno value is return to
+ *   indicate the nature of any failure.
+ *
+ * Assumptions:
+ *   The watchdog routine runs in the context of the timer interrupt handler
+ *   and is subject to all ISR restrictions.
+ *
+ ****************************************************************************/
+
+int wd_start_absolute(FAR struct wdog_s *wdog, clock_t ticks,
+                      wdentry_t wdentry, wdparm_t arg);
+
 /****************************************************************************
  * Name: wd_cancel
  *

sched/sched/sched.h

@@ -340,7 +340,7 @@ int  nxsched_reprioritize(FAR struct tcb_s *tcb, int sched_priority);
 /* Support for tickless operation */
 
 #ifdef CONFIG_SCHED_TICKLESS
-unsigned int nxsched_cancel_timer(void);
+clock_t nxsched_cancel_timer(void);
 void nxsched_resume_timer(void);
 void nxsched_reassess_timer(void);
 #else

sched/sched/sched_processtimer.c

@@ -157,7 +157,7 @@ static inline void nxsched_process_scheduler(void)
  ****************************************************************************/
 
 #ifdef CONFIG_SMP
-static inline void nxsched_process_wdtimer(void)
+static inline void nxsched_process_wdtimer(clock_t ticks)
 {
   irqstate_t flags;
 
@@ -171,11 +171,11 @@ static inline void nxsched_process_wdtimer(void)
    */
 
   flags = enter_critical_section();
-  wd_timer();
+  wd_timer(ticks);
   leave_critical_section(flags);
 }
 #else
-#  define nxsched_process_wdtimer() wd_timer()
+#  define nxsched_process_wdtimer(ticks) wd_timer(ticks)
 #endif
 
 /****************************************************************************
@@ -236,7 +236,7 @@ void nxsched_process_timer(void)
 
   /* Process watchdogs */
 
-  nxsched_process_wdtimer();
+  nxsched_process_wdtimer(clock_systime_ticks());
 
 #ifdef CONFIG_SYSTEMTICK_HOOK
   /* Call out to a user-provided function in order to perform board-specific,