Team2890/allwpilib
4
0
Fork 0
mirror of https://github.com/wpilibsuite/allwpilib synced 2026-06-19 00:41:43 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
c3b3fb8b74eaa336037624d9c3ee0a316c73bc0a
allwpilib/wpilibc/src/test/native/cpp/WatchdogTest.cpp

159 lines
4.1 KiB
C++
Raw Normal View History

Make Watchdog use single thread dispatch (#1347) Notifier has one thread per instance because the callbacks must be asynchronous. Watchdog callbacks can be synchronous, so this overhead can be done away with via a scheduler thread akin to what the HAL Notifier does.
2018-12-01 00:05:33 -08:00
/*----------------------------------------------------------------------------*/
[sim] Change StepTiming to wait for notifiers (#2603) Old behavior is available via StepTimingAsync. This makes it significantly easier to use simulation timing with notifiers. Also update tests to use simulation framework. This also speeds up the timing-dependent tests by using simulation timing. ResourceLock is used in the Java tests to prevent parallel execution. While we're here, tweak HAL Notifier implementation: - Use wait_for instead of wait_until in WaitForNotifierAlarm - Check for triggerTime = UINT64_MAX in UpdateNotifierAlarm
2020-09-27 13:27:53 -07:00
/* Copyright (c) 2018-2020 FIRST. All Rights Reserved. */
Make Watchdog use single thread dispatch (#1347) Notifier has one thread per instance because the callbacks must be asynchronous. Watchdog callbacks can be synchronous, so this overhead can be done away with via a scheduler thread akin to what the HAL Notifier does.
2018-12-01 00:05:33 -08:00
/* Open Source Software - may be modified and shared by FRC teams. The code */
/* must be accompanied by the FIRST BSD license file in the root directory of */
/* the project. */
/*----------------------------------------------------------------------------*/
#include "frc/Watchdog.h" // NOLINT(build/include_order)
#include <stdint.h>
#include <wpi/raw_ostream.h>
[sim] Change StepTiming to wait for notifiers (#2603) Old behavior is available via StepTimingAsync. This makes it significantly easier to use simulation timing with notifiers. Also update tests to use simulation framework. This also speeds up the timing-dependent tests by using simulation timing. ResourceLock is used in the Java tests to prevent parallel execution. While we're here, tweak HAL Notifier implementation: - Use wait_for instead of wait_until in WaitForNotifierAlarm - Check for triggerTime = UINT64_MAX in UpdateNotifierAlarm
2020-09-27 13:27:53 -07:00
#include "frc/simulation/SimHooks.h"
Make Watchdog use single thread dispatch (#1347) Notifier has one thread per instance because the callbacks must be asynchronous. Watchdog callbacks can be synchronous, so this overhead can be done away with via a scheduler thread akin to what the HAL Notifier does.
2018-12-01 00:05:33 -08:00
#include "gtest/gtest.h"
using namespace frc;
[sim] Change StepTiming to wait for notifiers (#2603) Old behavior is available via StepTimingAsync. This makes it significantly easier to use simulation timing with notifiers. Also update tests to use simulation framework. This also speeds up the timing-dependent tests by using simulation timing. ResourceLock is used in the Java tests to prevent parallel execution. While we're here, tweak HAL Notifier implementation: - Use wait_for instead of wait_until in WaitForNotifierAlarm - Check for triggerTime = UINT64_MAX in UpdateNotifierAlarm
2020-09-27 13:27:53 -07:00
namespace {
class WatchdogTest : public ::testing::Test {
protected:
void SetUp() override { frc::sim::PauseTiming(); }
void TearDown() override { frc::sim::ResumeTiming(); }
};
} // namespace
TEST_F(WatchdogTest, EnableDisable) {
Make Watchdog use single thread dispatch (#1347) Notifier has one thread per instance because the callbacks must be asynchronous. Watchdog callbacks can be synchronous, so this overhead can be done away with via a scheduler thread akin to what the HAL Notifier does.
2018-12-01 00:05:33 -08:00
uint32_t watchdogCounter = 0;
Watchdog: use units::second_t instead of double (#1863) Fixes #1827.
2019-09-03 15:58:31 -07:00
Watchdog watchdog(0.4_s, [&] { watchdogCounter++; });
Make Watchdog use single thread dispatch (#1347) Notifier has one thread per instance because the callbacks must be asynchronous. Watchdog callbacks can be synchronous, so this overhead can be done away with via a scheduler thread akin to what the HAL Notifier does.
2018-12-01 00:05:33 -08:00
wpi::outs() << "Run 1\n";
watchdog.Enable();
[sim] Change StepTiming to wait for notifiers (#2603) Old behavior is available via StepTimingAsync. This makes it significantly easier to use simulation timing with notifiers. Also update tests to use simulation framework. This also speeds up the timing-dependent tests by using simulation timing. ResourceLock is used in the Java tests to prevent parallel execution. While we're here, tweak HAL Notifier implementation: - Use wait_for instead of wait_until in WaitForNotifierAlarm - Check for triggerTime = UINT64_MAX in UpdateNotifierAlarm
2020-09-27 13:27:53 -07:00
frc::sim::StepTiming(0.2_s);
Make Watchdog use single thread dispatch (#1347) Notifier has one thread per instance because the callbacks must be asynchronous. Watchdog callbacks can be synchronous, so this overhead can be done away with via a scheduler thread akin to what the HAL Notifier does.
2018-12-01 00:05:33 -08:00
watchdog.Disable();
EXPECT_EQ(0u, watchdogCounter) << "Watchdog triggered early";
wpi::outs() << "Run 2\n";
watchdogCounter = 0;
watchdog.Enable();
[sim] Change StepTiming to wait for notifiers (#2603) Old behavior is available via StepTimingAsync. This makes it significantly easier to use simulation timing with notifiers. Also update tests to use simulation framework. This also speeds up the timing-dependent tests by using simulation timing. ResourceLock is used in the Java tests to prevent parallel execution. While we're here, tweak HAL Notifier implementation: - Use wait_for instead of wait_until in WaitForNotifierAlarm - Check for triggerTime = UINT64_MAX in UpdateNotifierAlarm
2020-09-27 13:27:53 -07:00
frc::sim::StepTiming(0.6_s);
Make Watchdog use single thread dispatch (#1347) Notifier has one thread per instance because the callbacks must be asynchronous. Watchdog callbacks can be synchronous, so this overhead can be done away with via a scheduler thread akin to what the HAL Notifier does.
2018-12-01 00:05:33 -08:00
watchdog.Disable();
EXPECT_EQ(1u, watchdogCounter)
<< "Watchdog either didn't trigger or triggered more than once";
wpi::outs() << "Run 3\n";
watchdogCounter = 0;
watchdog.Enable();
[sim] Change StepTiming to wait for notifiers (#2603) Old behavior is available via StepTimingAsync. This makes it significantly easier to use simulation timing with notifiers. Also update tests to use simulation framework. This also speeds up the timing-dependent tests by using simulation timing. ResourceLock is used in the Java tests to prevent parallel execution. While we're here, tweak HAL Notifier implementation: - Use wait_for instead of wait_until in WaitForNotifierAlarm - Check for triggerTime = UINT64_MAX in UpdateNotifierAlarm
2020-09-27 13:27:53 -07:00
frc::sim::StepTiming(1_s);
Make Watchdog use single thread dispatch (#1347) Notifier has one thread per instance because the callbacks must be asynchronous. Watchdog callbacks can be synchronous, so this overhead can be done away with via a scheduler thread akin to what the HAL Notifier does.
2018-12-01 00:05:33 -08:00
watchdog.Disable();
EXPECT_EQ(1u, watchdogCounter)
<< "Watchdog either didn't trigger or triggered more than once";
}
[sim] Change StepTiming to wait for notifiers (#2603) Old behavior is available via StepTimingAsync. This makes it significantly easier to use simulation timing with notifiers. Also update tests to use simulation framework. This also speeds up the timing-dependent tests by using simulation timing. ResourceLock is used in the Java tests to prevent parallel execution. While we're here, tweak HAL Notifier implementation: - Use wait_for instead of wait_until in WaitForNotifierAlarm - Check for triggerTime = UINT64_MAX in UpdateNotifierAlarm
2020-09-27 13:27:53 -07:00
TEST_F(WatchdogTest, Reset) {
Make Watchdog use single thread dispatch (#1347) Notifier has one thread per instance because the callbacks must be asynchronous. Watchdog callbacks can be synchronous, so this overhead can be done away with via a scheduler thread akin to what the HAL Notifier does.
2018-12-01 00:05:33 -08:00
uint32_t watchdogCounter = 0;
Watchdog: use units::second_t instead of double (#1863) Fixes #1827.
2019-09-03 15:58:31 -07:00
Watchdog watchdog(0.4_s, [&] { watchdogCounter++; });
Make Watchdog use single thread dispatch (#1347) Notifier has one thread per instance because the callbacks must be asynchronous. Watchdog callbacks can be synchronous, so this overhead can be done away with via a scheduler thread akin to what the HAL Notifier does.
2018-12-01 00:05:33 -08:00
watchdog.Enable();
[sim] Change StepTiming to wait for notifiers (#2603) Old behavior is available via StepTimingAsync. This makes it significantly easier to use simulation timing with notifiers. Also update tests to use simulation framework. This also speeds up the timing-dependent tests by using simulation timing. ResourceLock is used in the Java tests to prevent parallel execution. While we're here, tweak HAL Notifier implementation: - Use wait_for instead of wait_until in WaitForNotifierAlarm - Check for triggerTime = UINT64_MAX in UpdateNotifierAlarm
2020-09-27 13:27:53 -07:00
frc::sim::StepTiming(0.2_s);
Make Watchdog use single thread dispatch (#1347) Notifier has one thread per instance because the callbacks must be asynchronous. Watchdog callbacks can be synchronous, so this overhead can be done away with via a scheduler thread akin to what the HAL Notifier does.
2018-12-01 00:05:33 -08:00
watchdog.Reset();
[sim] Change StepTiming to wait for notifiers (#2603) Old behavior is available via StepTimingAsync. This makes it significantly easier to use simulation timing with notifiers. Also update tests to use simulation framework. This also speeds up the timing-dependent tests by using simulation timing. ResourceLock is used in the Java tests to prevent parallel execution. While we're here, tweak HAL Notifier implementation: - Use wait_for instead of wait_until in WaitForNotifierAlarm - Check for triggerTime = UINT64_MAX in UpdateNotifierAlarm
2020-09-27 13:27:53 -07:00
frc::sim::StepTiming(0.2_s);
Make Watchdog use single thread dispatch (#1347) Notifier has one thread per instance because the callbacks must be asynchronous. Watchdog callbacks can be synchronous, so this overhead can be done away with via a scheduler thread akin to what the HAL Notifier does.
2018-12-01 00:05:33 -08:00
watchdog.Disable();
EXPECT_EQ(0u, watchdogCounter) << "Watchdog triggered early";
}
[sim] Change StepTiming to wait for notifiers (#2603) Old behavior is available via StepTimingAsync. This makes it significantly easier to use simulation timing with notifiers. Also update tests to use simulation framework. This also speeds up the timing-dependent tests by using simulation timing. ResourceLock is used in the Java tests to prevent parallel execution. While we're here, tweak HAL Notifier implementation: - Use wait_for instead of wait_until in WaitForNotifierAlarm - Check for triggerTime = UINT64_MAX in UpdateNotifierAlarm
2020-09-27 13:27:53 -07:00
TEST_F(WatchdogTest, SetTimeout) {
Make Watchdog use single thread dispatch (#1347) Notifier has one thread per instance because the callbacks must be asynchronous. Watchdog callbacks can be synchronous, so this overhead can be done away with via a scheduler thread akin to what the HAL Notifier does.
2018-12-01 00:05:33 -08:00
uint32_t watchdogCounter = 0;
Watchdog: use units::second_t instead of double (#1863) Fixes #1827.
2019-09-03 15:58:31 -07:00
Watchdog watchdog(1.0_s, [&] { watchdogCounter++; });
Make Watchdog use single thread dispatch (#1347) Notifier has one thread per instance because the callbacks must be asynchronous. Watchdog callbacks can be synchronous, so this overhead can be done away with via a scheduler thread akin to what the HAL Notifier does.
2018-12-01 00:05:33 -08:00
watchdog.Enable();
[sim] Change StepTiming to wait for notifiers (#2603) Old behavior is available via StepTimingAsync. This makes it significantly easier to use simulation timing with notifiers. Also update tests to use simulation framework. This also speeds up the timing-dependent tests by using simulation timing. ResourceLock is used in the Java tests to prevent parallel execution. While we're here, tweak HAL Notifier implementation: - Use wait_for instead of wait_until in WaitForNotifierAlarm - Check for triggerTime = UINT64_MAX in UpdateNotifierAlarm
2020-09-27 13:27:53 -07:00
frc::sim::StepTiming(0.2_s);
Watchdog: use units::second_t instead of double (#1863) Fixes #1827.
2019-09-03 15:58:31 -07:00
watchdog.SetTimeout(0.2_s);
Make Watchdog use single thread dispatch (#1347) Notifier has one thread per instance because the callbacks must be asynchronous. Watchdog callbacks can be synchronous, so this overhead can be done away with via a scheduler thread akin to what the HAL Notifier does.
2018-12-01 00:05:33 -08:00
EXPECT_EQ(0.2, watchdog.GetTimeout());
EXPECT_EQ(0u, watchdogCounter) << "Watchdog triggered early";
[sim] Change StepTiming to wait for notifiers (#2603) Old behavior is available via StepTimingAsync. This makes it significantly easier to use simulation timing with notifiers. Also update tests to use simulation framework. This also speeds up the timing-dependent tests by using simulation timing. ResourceLock is used in the Java tests to prevent parallel execution. While we're here, tweak HAL Notifier implementation: - Use wait_for instead of wait_until in WaitForNotifierAlarm - Check for triggerTime = UINT64_MAX in UpdateNotifierAlarm
2020-09-27 13:27:53 -07:00
frc::sim::StepTiming(0.3_s);
Make Watchdog use single thread dispatch (#1347) Notifier has one thread per instance because the callbacks must be asynchronous. Watchdog callbacks can be synchronous, so this overhead can be done away with via a scheduler thread akin to what the HAL Notifier does.
2018-12-01 00:05:33 -08:00
watchdog.Disable();
EXPECT_EQ(1u, watchdogCounter)
<< "Watchdog either didn't trigger or triggered more than once";
}
[sim] Change StepTiming to wait for notifiers (#2603) Old behavior is available via StepTimingAsync. This makes it significantly easier to use simulation timing with notifiers. Also update tests to use simulation framework. This also speeds up the timing-dependent tests by using simulation timing. ResourceLock is used in the Java tests to prevent parallel execution. While we're here, tweak HAL Notifier implementation: - Use wait_for instead of wait_until in WaitForNotifierAlarm - Check for triggerTime = UINT64_MAX in UpdateNotifierAlarm
2020-09-27 13:27:53 -07:00
TEST_F(WatchdogTest, IsExpired) {
Watchdog: use units::second_t instead of double (#1863) Fixes #1827.
2019-09-03 15:58:31 -07:00
Watchdog watchdog(0.2_s, [] {});
Fix Watchdog incorrectly resetting expiration flag upon disable (#1580) Resetting the flag should only occur in Enable() and Reset(). IterativeRobotBase needs the flag to remain set to print epochs after disabling the Watchdog.
2019-02-02 00:22:07 -08:00
EXPECT_FALSE(watchdog.IsExpired());
Make Watchdog use single thread dispatch (#1347) Notifier has one thread per instance because the callbacks must be asynchronous. Watchdog callbacks can be synchronous, so this overhead can be done away with via a scheduler thread akin to what the HAL Notifier does.
2018-12-01 00:05:33 -08:00
watchdog.Enable();
EXPECT_FALSE(watchdog.IsExpired());
[sim] Change StepTiming to wait for notifiers (#2603) Old behavior is available via StepTimingAsync. This makes it significantly easier to use simulation timing with notifiers. Also update tests to use simulation framework. This also speeds up the timing-dependent tests by using simulation timing. ResourceLock is used in the Java tests to prevent parallel execution. While we're here, tweak HAL Notifier implementation: - Use wait_for instead of wait_until in WaitForNotifierAlarm - Check for triggerTime = UINT64_MAX in UpdateNotifierAlarm
2020-09-27 13:27:53 -07:00
frc::sim::StepTiming(0.3_s);
Make Watchdog use single thread dispatch (#1347) Notifier has one thread per instance because the callbacks must be asynchronous. Watchdog callbacks can be synchronous, so this overhead can be done away with via a scheduler thread akin to what the HAL Notifier does.
2018-12-01 00:05:33 -08:00
EXPECT_TRUE(watchdog.IsExpired());
Fix Watchdog incorrectly resetting expiration flag upon disable (#1580) Resetting the flag should only occur in Enable() and Reset(). IterativeRobotBase needs the flag to remain set to print epochs after disabling the Watchdog.
2019-02-02 00:22:07 -08:00
watchdog.Disable();
EXPECT_TRUE(watchdog.IsExpired());
watchdog.Reset();
EXPECT_FALSE(watchdog.IsExpired());
Make Watchdog use single thread dispatch (#1347) Notifier has one thread per instance because the callbacks must be asynchronous. Watchdog callbacks can be synchronous, so this overhead can be done away with via a scheduler thread akin to what the HAL Notifier does.
2018-12-01 00:05:33 -08:00
}
[sim] Change StepTiming to wait for notifiers (#2603) Old behavior is available via StepTimingAsync. This makes it significantly easier to use simulation timing with notifiers. Also update tests to use simulation framework. This also speeds up the timing-dependent tests by using simulation timing. ResourceLock is used in the Java tests to prevent parallel execution. While we're here, tweak HAL Notifier implementation: - Use wait_for instead of wait_until in WaitForNotifierAlarm - Check for triggerTime = UINT64_MAX in UpdateNotifierAlarm
2020-09-27 13:27:53 -07:00
TEST_F(WatchdogTest, Epochs) {
Make Watchdog use single thread dispatch (#1347) Notifier has one thread per instance because the callbacks must be asynchronous. Watchdog callbacks can be synchronous, so this overhead can be done away with via a scheduler thread akin to what the HAL Notifier does.
2018-12-01 00:05:33 -08:00
uint32_t watchdogCounter = 0;
Watchdog: use units::second_t instead of double (#1863) Fixes #1827.
2019-09-03 15:58:31 -07:00
Watchdog watchdog(0.4_s, [&] { watchdogCounter++; });
Make Watchdog use single thread dispatch (#1347) Notifier has one thread per instance because the callbacks must be asynchronous. Watchdog callbacks can be synchronous, so this overhead can be done away with via a scheduler thread akin to what the HAL Notifier does.
2018-12-01 00:05:33 -08:00
wpi::outs() << "Run 1\n";
watchdog.Enable();
watchdog.AddEpoch("Epoch 1");
[sim] Change StepTiming to wait for notifiers (#2603) Old behavior is available via StepTimingAsync. This makes it significantly easier to use simulation timing with notifiers. Also update tests to use simulation framework. This also speeds up the timing-dependent tests by using simulation timing. ResourceLock is used in the Java tests to prevent parallel execution. While we're here, tweak HAL Notifier implementation: - Use wait_for instead of wait_until in WaitForNotifierAlarm - Check for triggerTime = UINT64_MAX in UpdateNotifierAlarm
2020-09-27 13:27:53 -07:00
frc::sim::StepTiming(0.1_s);
Make Watchdog use single thread dispatch (#1347) Notifier has one thread per instance because the callbacks must be asynchronous. Watchdog callbacks can be synchronous, so this overhead can be done away with via a scheduler thread akin to what the HAL Notifier does.
2018-12-01 00:05:33 -08:00
watchdog.AddEpoch("Epoch 2");
[sim] Change StepTiming to wait for notifiers (#2603) Old behavior is available via StepTimingAsync. This makes it significantly easier to use simulation timing with notifiers. Also update tests to use simulation framework. This also speeds up the timing-dependent tests by using simulation timing. ResourceLock is used in the Java tests to prevent parallel execution. While we're here, tweak HAL Notifier implementation: - Use wait_for instead of wait_until in WaitForNotifierAlarm - Check for triggerTime = UINT64_MAX in UpdateNotifierAlarm
2020-09-27 13:27:53 -07:00
frc::sim::StepTiming(0.1_s);
Make Watchdog use single thread dispatch (#1347) Notifier has one thread per instance because the callbacks must be asynchronous. Watchdog callbacks can be synchronous, so this overhead can be done away with via a scheduler thread akin to what the HAL Notifier does.
2018-12-01 00:05:33 -08:00
watchdog.AddEpoch("Epoch 3");
watchdog.Disable();
EXPECT_EQ(0u, watchdogCounter) << "Watchdog triggered early";
wpi::outs() << "Run 2\n";
watchdog.Enable();
watchdog.AddEpoch("Epoch 1");
[sim] Change StepTiming to wait for notifiers (#2603) Old behavior is available via StepTimingAsync. This makes it significantly easier to use simulation timing with notifiers. Also update tests to use simulation framework. This also speeds up the timing-dependent tests by using simulation timing. ResourceLock is used in the Java tests to prevent parallel execution. While we're here, tweak HAL Notifier implementation: - Use wait_for instead of wait_until in WaitForNotifierAlarm - Check for triggerTime = UINT64_MAX in UpdateNotifierAlarm
2020-09-27 13:27:53 -07:00
frc::sim::StepTiming(0.2_s);
Make Watchdog use single thread dispatch (#1347) Notifier has one thread per instance because the callbacks must be asynchronous. Watchdog callbacks can be synchronous, so this overhead can be done away with via a scheduler thread akin to what the HAL Notifier does.
2018-12-01 00:05:33 -08:00
watchdog.Reset();
[sim] Change StepTiming to wait for notifiers (#2603) Old behavior is available via StepTimingAsync. This makes it significantly easier to use simulation timing with notifiers. Also update tests to use simulation framework. This also speeds up the timing-dependent tests by using simulation timing. ResourceLock is used in the Java tests to prevent parallel execution. While we're here, tweak HAL Notifier implementation: - Use wait_for instead of wait_until in WaitForNotifierAlarm - Check for triggerTime = UINT64_MAX in UpdateNotifierAlarm
2020-09-27 13:27:53 -07:00
frc::sim::StepTiming(0.2_s);
Make Watchdog use single thread dispatch (#1347) Notifier has one thread per instance because the callbacks must be asynchronous. Watchdog callbacks can be synchronous, so this overhead can be done away with via a scheduler thread akin to what the HAL Notifier does.
2018-12-01 00:05:33 -08:00
watchdog.AddEpoch("Epoch 2");
watchdog.Disable();
EXPECT_EQ(0u, watchdogCounter) << "Watchdog triggered early";
}
[sim] Change StepTiming to wait for notifiers (#2603) Old behavior is available via StepTimingAsync. This makes it significantly easier to use simulation timing with notifiers. Also update tests to use simulation framework. This also speeds up the timing-dependent tests by using simulation timing. ResourceLock is used in the Java tests to prevent parallel execution. While we're here, tweak HAL Notifier implementation: - Use wait_for instead of wait_until in WaitForNotifierAlarm - Check for triggerTime = UINT64_MAX in UpdateNotifierAlarm
2020-09-27 13:27:53 -07:00
TEST_F(WatchdogTest, MultiWatchdog) {
Make Watchdog use single thread dispatch (#1347) Notifier has one thread per instance because the callbacks must be asynchronous. Watchdog callbacks can be synchronous, so this overhead can be done away with via a scheduler thread akin to what the HAL Notifier does.
2018-12-01 00:05:33 -08:00
uint32_t watchdogCounter1 = 0;
uint32_t watchdogCounter2 = 0;
Watchdog: use units::second_t instead of double (#1863) Fixes #1827.
2019-09-03 15:58:31 -07:00
Watchdog watchdog1(0.2_s, [&] { watchdogCounter1++; });
Watchdog watchdog2(0.6_s, [&] { watchdogCounter2++; });
Make Watchdog use single thread dispatch (#1347) Notifier has one thread per instance because the callbacks must be asynchronous. Watchdog callbacks can be synchronous, so this overhead can be done away with via a scheduler thread akin to what the HAL Notifier does.
2018-12-01 00:05:33 -08:00
watchdog2.Enable();
[sim] Change StepTiming to wait for notifiers (#2603) Old behavior is available via StepTimingAsync. This makes it significantly easier to use simulation timing with notifiers. Also update tests to use simulation framework. This also speeds up the timing-dependent tests by using simulation timing. ResourceLock is used in the Java tests to prevent parallel execution. While we're here, tweak HAL Notifier implementation: - Use wait_for instead of wait_until in WaitForNotifierAlarm - Check for triggerTime = UINT64_MAX in UpdateNotifierAlarm
2020-09-27 13:27:53 -07:00
frc::sim::StepTiming(0.25_s);
Make Watchdog use single thread dispatch (#1347) Notifier has one thread per instance because the callbacks must be asynchronous. Watchdog callbacks can be synchronous, so this overhead can be done away with via a scheduler thread akin to what the HAL Notifier does.
2018-12-01 00:05:33 -08:00
EXPECT_EQ(0u, watchdogCounter1) << "Watchdog triggered early";
EXPECT_EQ(0u, watchdogCounter2) << "Watchdog triggered early";
// Sleep enough such that only the watchdog enabled later times out first
watchdog1.Enable();
[sim] Change StepTiming to wait for notifiers (#2603) Old behavior is available via StepTimingAsync. This makes it significantly easier to use simulation timing with notifiers. Also update tests to use simulation framework. This also speeds up the timing-dependent tests by using simulation timing. ResourceLock is used in the Java tests to prevent parallel execution. While we're here, tweak HAL Notifier implementation: - Use wait_for instead of wait_until in WaitForNotifierAlarm - Check for triggerTime = UINT64_MAX in UpdateNotifierAlarm
2020-09-27 13:27:53 -07:00
frc::sim::StepTiming(0.25_s);
Make Watchdog use single thread dispatch (#1347) Notifier has one thread per instance because the callbacks must be asynchronous. Watchdog callbacks can be synchronous, so this overhead can be done away with via a scheduler thread akin to what the HAL Notifier does.
2018-12-01 00:05:33 -08:00
watchdog1.Disable();
watchdog2.Disable();
EXPECT_EQ(1u, watchdogCounter1)
<< "Watchdog either didn't trigger or triggered more than once";
EXPECT_EQ(0u, watchdogCounter2) << "Watchdog triggered early";
}
Reference in New Issue Copy Permalink