Scheduler

2026-10-20 06:33:33 +08:00 · 2014-03-08 01:01:50 +04:00
parent fb5840116a
commit aef70367d9
5 changed files with 444 additions and 0 deletions
@@ -0,0 +1,105 @@
+/*
+ * Copyright (C) 2014 Pavel Kirienko <pavel.kirienko@gmail.com>
+ */
+
+#include <gtest/gtest.h>
+#include <uavcan/scheduler.hpp>
+#include "common.hpp"
+#include "transport/can/iface_mock.hpp"
+
+static const unsigned int TimestampPrecisionMs = 10;
+
+struct TimerCallCounter
+{
+    std::vector<uavcan::TimerEvent> events_a;
+    std::vector<uavcan::TimerEvent> events_b;
+
+    void callA(const uavcan::TimerEvent& ev) { events_a.push_back(ev); }
+    void callB(const uavcan::TimerEvent& ev) { events_b.push_back(ev); }
+
+    typedef uavcan::MethodBinder<TimerCallCounter*, void(TimerCallCounter::*)(const uavcan::TimerEvent&)> Binder;
+};
+
+static bool timestampsEqual(int64_t a, int64_t b)
+{
+    return std::abs(a - b) < (TimestampPrecisionMs * 1000);
+}
+
+/*
+ * This test can fail on a non real time system. That's kinda sad but okay.
+ */
+TEST(Scheduler, Timers)
+{
+    uavcan::PoolAllocator<uavcan::MemPoolBlockSize * 8, uavcan::MemPoolBlockSize> pool;
+    uavcan::PoolManager<1> poolmgr;
+    poolmgr.addPool(&pool);
+
+    SystemClockDriver clock_driver;
+    CanDriverMock can_driver(2, clock_driver);
+
+    uavcan::OutgoingTransferRegistry<8> out_trans_reg(poolmgr);
+
+    uavcan::Scheduler sch(can_driver, poolmgr, clock_driver, out_trans_reg, uavcan::NodeID(1));
+
+    /*
+     * Registration
+     */
+    {
+        TimerCallCounter tcc;
+        uavcan::Timer<TimerCallCounter::Binder> a(sch, TimerCallCounter::Binder(&tcc, &TimerCallCounter::callA));
+        uavcan::Timer<TimerCallCounter::Binder> b(sch, TimerCallCounter::Binder(&tcc, &TimerCallCounter::callB));
+
+        ASSERT_EQ(0, sch.getNumOneShotTimers());
+        ASSERT_FALSE(sch.isOneShotTimerRegistered(&a));
+        ASSERT_FALSE(sch.isOneShotTimerRegistered(&b));
+
+        const uint64_t start_ts = clock_driver.getMonotonicMicroseconds();
+
+        a.startOneShotDeadline(start_ts + 100000);
+        b.startPeriodic(1000);
+
+        ASSERT_EQ(2, sch.getNumOneShotTimers());
+        ASSERT_TRUE(sch.isOneShotTimerRegistered(&a));
+        ASSERT_TRUE(sch.isOneShotTimerRegistered(&b));
+
+        /*
+         * Spinning
+         */
+        ASSERT_EQ(0, sch.spin(start_ts + 1000000));
+
+        ASSERT_EQ(1, tcc.events_a.size());
+        ASSERT_TRUE(timestampsEqual(tcc.events_a[0].scheduled_monotonic_deadline, start_ts + 100000));
+        ASSERT_TRUE(timestampsEqual(tcc.events_a[0].monotonic_timestamp, tcc.events_a[0].scheduled_monotonic_deadline));
+        ASSERT_EQ(&a, tcc.events_a[0].timer);
+
+        ASSERT_LT(900, tcc.events_b.size());
+        ASSERT_GT(1100, tcc.events_b.size());
+        {
+            uint64_t next_expected_deadline = start_ts + 1000;
+            for (unsigned int i = 0; i < tcc.events_b.size(); i++)
+            {
+                ASSERT_TRUE(timestampsEqual(tcc.events_b[i].scheduled_monotonic_deadline, next_expected_deadline));
+                ASSERT_TRUE(timestampsEqual(tcc.events_b[i].monotonic_timestamp,
+                                            tcc.events_b[i].scheduled_monotonic_deadline));
+                ASSERT_EQ(&b, tcc.events_b[i].timer);
+                next_expected_deadline += 1000;
+            }
+        }
+
+        /*
+         * Deinitialization
+         */
+        ASSERT_EQ(1, sch.getNumOneShotTimers());
+
+        ASSERT_FALSE(sch.isOneShotTimerRegistered(&a));
+        ASSERT_FALSE(a.isRunning());
+        ASSERT_EQ(uavcan::TimerBase::InfinitePeriod, a.getPeriod());
+
+        ASSERT_TRUE(sch.isOneShotTimerRegistered(&b));
+        ASSERT_TRUE(b.isRunning());
+        ASSERT_EQ(1000, b.getPeriod());
+    }
+
+    ASSERT_EQ(0, sch.getNumOneShotTimers());                                 // Both timers were destroyed now
+    ASSERT_EQ(0, sch.spin(clock_driver.getMonotonicMicroseconds() + 1000));  // Spin some more without timers
+}