[hal] Revamp notifiers (#8424)

This changes the HAL notifier interface to:
- Use wpiutil signal objects. This means waiting is done through the
`WPI_WaitObject` API instead of a dedicated function and allows for
higher level code to simultaneously wait on notifiers and other events.
- Interval timers are supported at the HAL layer
- Handlers are now required to acknowledge notifications. This is
invisible to users unless they're directly using the HAL API.
- For interval timers, an overrun count is maintained to detect if the
handler didn't acknowledge

The underlying implementation still uses condition variables for the
actual waiting. In basic testing using this approach seemed to be lower
jitter than timerfd.

Currently, the simulation and systemcore implementations are nearly
identical except for a few additional sim hook bits. This could be
refactored, but keeping them separate may make sense to keep the
systemcore implementation easy to read and reason about, or if we ever
choose to use a different underlying timer implementation on systemcore.

The simulation side API is unchanged in form but does change in
function--waiting for notifiers now only waits for currently running (or
newly signaled) notifiers to acknowledge. To avoid a race condition in
sim stepTiming, users of the low level API must make any alarm updates
(especially for one-shot alarms) prior to acknowledging the previous
alarm.

The only current use of the interval timer feature is the `Notifier`
class. The `TimedRobot` implementation still uses a single notifier and
its own interval timing logic to ensure consistent callback order. Using
separate notifiers for each user-level interval would substantially
increase complexity. `Watchdog` also doesn't use the interval timer, as
it's looking for an amount of time since the last `set` call rather than
a recurring interval time.

To reduce flicker, the sim GUI uses a fade out when a timeout goes from
set to unset.

This fixes tsan for wpilib and commands, and also fixes some spurious
test failures.

wpilibj/src/main/java/org/wpilib/system/Watchdog.java

@@ -10,8 +10,10 @@ import java.io.Closeable;
 import java.util.PriorityQueue;
 import java.util.concurrent.locks.ReentrantLock;
 import org.wpilib.driverstation.DriverStation;
+import org.wpilib.hardware.hal.HALUtil;
 import org.wpilib.hardware.hal.NotifierJNI;
 import org.wpilib.units.measure.Time;
+import org.wpilib.util.WPIUtilJNI;
 
 /**
  * A class that's a wrapper around a watchdog timer.
@@ -42,7 +44,7 @@ public class Watchdog implements Closeable, Comparable<Watchdog> {
   private static int m_notifier;
 
   static {
-    m_notifier = NotifierJNI.initializeNotifier();
+    m_notifier = NotifierJNI.createNotifier();
     NotifierJNI.setNotifierName(m_notifier, "Watchdog");
     startDaemonThread(Watchdog::schedulerFunc);
   }
@@ -225,8 +227,8 @@ public class Watchdog implements Closeable, Comparable<Watchdog> {
     if (m_watchdogs.isEmpty()) {
       NotifierJNI.cancelNotifierAlarm(m_notifier);
     } else {
-      NotifierJNI.updateNotifierAlarm(
-          m_notifier, (long) (m_watchdogs.peek().m_expirationTime * 1e6));
+      NotifierJNI.setNotifierAlarm(
+          m_notifier, (long) (m_watchdogs.peek().m_expirationTime * 1e6), 0, true);
     }
   }
 
@@ -239,10 +241,13 @@ public class Watchdog implements Closeable, Comparable<Watchdog> {
 
   private static void schedulerFunc() {
     while (!Thread.currentThread().isInterrupted()) {
-      long curTime = NotifierJNI.waitForNotifierAlarm(m_notifier);
-      if (curTime == 0) {
+      try {
+        WPIUtilJNI.waitForObject(m_notifier);
+      } catch (InterruptedException ex) {
+        Thread.currentThread().interrupt();
         break;
       }
+      long curTime = HALUtil.getFPGATime();
 
       m_queueMutex.lock();
       try {
@@ -273,6 +278,8 @@ public class Watchdog implements Closeable, Comparable<Watchdog> {
         m_queueMutex.lock();
 
         updateAlarm();
+
+        NotifierJNI.acknowledgeNotifierAlarm(m_notifier);
       } finally {
         m_queueMutex.unlock();
       }