Martino FerrariandClaude Opus 4.6
7102412a9f
Review found the decoder was estimating something the wire states exactly. FrameView::counter increments once per update, so a gap of g means g-1 lost datagrams; reinstating their duration restores the hole precisely, with no threshold and no dependence on arrival time. The arrival-anchor comparison survives only as a backstop for what the counter cannot express — a producer restart, a counter stuck at zero, a wrong declared rate — and can no longer step a signal's timestamps backwards, which the ring and trigger forbid. Also from review: guard the time-signal lookup against a frame carrying more signals than the installed table, and give FrameBuilder a counter parameter. Leaving it at zero had hidden the counter rules from every test, and made the hrt-gap test vacuous — under uniform arrivals the hrt path and packetBurst agree by construction, so it could not tell which branch answered. Its arrivals now carry zero-mean jitter. Each new assertion was proven non-vacuous by sabotage: dropping the gap term, the backward guard, or the hrt branch fails exactly its own test. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
383 lines
13 KiB
C++
383 lines
13 KiB
C++
#include "FrameDecoder.h"
|
|
|
|
#include <gtest/gtest.h>
|
|
|
|
#include <vector>
|
|
|
|
using namespace udpscope;
|
|
|
|
namespace {
|
|
|
|
/** Builds a FrameView over vectors the test owns. */
|
|
struct FrameBuilder {
|
|
std::vector<std::vector<double>> storage;
|
|
std::vector<const double*> ptrs;
|
|
std::vector<uint32_t> counts;
|
|
FrameView view;
|
|
|
|
void addSignal(std::vector<double> vals) {
|
|
storage.push_back(std::move(vals));
|
|
}
|
|
|
|
/* Real frames carry a per-update counter; leaving it at zero would hide
|
|
* whichever rules depend on it, so it must be passed explicitly. */
|
|
const FrameView& build(uint64_t hrt, double recvTime, uint32_t numSamples = 1,
|
|
uint32_t counter = 0) {
|
|
ptrs.clear();
|
|
counts.clear();
|
|
for (const auto& s : storage) {
|
|
ptrs.push_back(s.data());
|
|
counts.push_back(static_cast<uint32_t>(s.size()));
|
|
}
|
|
view.counter = counter;
|
|
view.hrt = hrt;
|
|
view.recvTime = recvTime;
|
|
view.numSamples = numSamples;
|
|
view.numSignals = static_cast<uint32_t>(storage.size());
|
|
view.values = ptrs.data();
|
|
view.counts = counts.data();
|
|
return view;
|
|
}
|
|
};
|
|
|
|
SignalMeta burst(const char* name, uint8_t timeMode, double rate,
|
|
uint32_t elems, uint32_t timeIdx) {
|
|
SignalMeta m;
|
|
m.name = name;
|
|
m.typeCode = 8; /* float32 */
|
|
m.numRows = elems;
|
|
m.numCols = 1;
|
|
m.timeMode = timeMode;
|
|
m.samplingRate = rate;
|
|
m.timeSignalIdx = timeIdx;
|
|
return m;
|
|
}
|
|
|
|
SignalMeta timeSignal(const char* name, uint32_t elems) {
|
|
SignalMeta m;
|
|
m.name = name;
|
|
m.typeCode = 6; /* uint64 -> nanoseconds */
|
|
m.numRows = elems;
|
|
m.numCols = 1;
|
|
return m;
|
|
}
|
|
|
|
} /* namespace */
|
|
|
|
TEST(FrameDecoder, FullArrayTakesOneStampPerElementFromTheTimeSignal) {
|
|
FrameDecoder dec;
|
|
dec.setSignals({burst("Sine", kTimeFullArray, 1000.0, 4, 1),
|
|
timeSignal("Time", 4)});
|
|
|
|
FrameBuilder fb;
|
|
fb.addSignal({1.0, 2.0, 3.0, 4.0});
|
|
/* Nanoseconds: 5.000, 5.001, 5.002, 5.003 s of producer time. */
|
|
fb.addSignal({5.0e9, 5.001e9, 5.002e9, 5.003e9});
|
|
const FrameView& f = fb.build(0, 1000.0);
|
|
|
|
dec.beginFrame(f);
|
|
std::vector<double> ts;
|
|
ASSERT_TRUE(dec.timestamps(f, 0, ts));
|
|
ASSERT_EQ(ts.size(), 4u);
|
|
|
|
/* Element 0 lands on the arrival time; the rest keep the producer spacing. */
|
|
EXPECT_NEAR(ts[0], 1000.000, 1e-9);
|
|
EXPECT_NEAR(ts[1], 1000.001, 1e-9);
|
|
EXPECT_NEAR(ts[2], 1000.002, 1e-9);
|
|
EXPECT_NEAR(ts[3], 1000.003, 1e-9);
|
|
}
|
|
|
|
TEST(FrameDecoder, FirstSampleAnchorsElementZeroAndCountsForward) {
|
|
FrameDecoder dec;
|
|
dec.setSignals({burst("Sine", kTimeFirstSample, 1000.0, 4, 1),
|
|
timeSignal("Time", 1)});
|
|
|
|
FrameBuilder fb;
|
|
fb.addSignal({1.0, 2.0, 3.0, 4.0});
|
|
fb.addSignal({7.0e9});
|
|
const FrameView& f = fb.build(0, 2000.0);
|
|
|
|
dec.beginFrame(f);
|
|
std::vector<double> ts;
|
|
ASSERT_TRUE(dec.timestamps(f, 0, ts));
|
|
ASSERT_EQ(ts.size(), 4u);
|
|
EXPECT_NEAR(ts[0], 2000.000, 1e-9);
|
|
EXPECT_NEAR(ts[3], 2000.003, 1e-9);
|
|
}
|
|
|
|
TEST(FrameDecoder, LastSampleAnchorsTheFinalElementAndCountsBackward) {
|
|
FrameDecoder dec;
|
|
dec.setSignals({burst("Sine", kTimeLastSample, 1000.0, 4, 1),
|
|
timeSignal("Time", 1)});
|
|
|
|
FrameBuilder fb;
|
|
fb.addSignal({1.0, 2.0, 3.0, 4.0});
|
|
fb.addSignal({7.0e9});
|
|
const FrameView& f = fb.build(0, 3000.0);
|
|
|
|
dec.beginFrame(f);
|
|
std::vector<double> ts;
|
|
ASSERT_TRUE(dec.timestamps(f, 0, ts));
|
|
ASSERT_EQ(ts.size(), 4u);
|
|
EXPECT_NEAR(ts[3], 3000.000, 1e-9);
|
|
EXPECT_NEAR(ts[0], 3000.000 - 0.003, 1e-9);
|
|
}
|
|
|
|
TEST(FrameDecoder, PlainScalarUsesArrivalTime) {
|
|
FrameDecoder dec;
|
|
SignalMeta m;
|
|
m.name = "Level";
|
|
m.typeCode = 9;
|
|
dec.setSignals({m});
|
|
|
|
FrameBuilder fb;
|
|
fb.addSignal({42.0});
|
|
const FrameView& f = fb.build(0, 1234.5);
|
|
|
|
dec.beginFrame(f);
|
|
std::vector<double> ts;
|
|
ASSERT_TRUE(dec.timestamps(f, 0, ts));
|
|
ASSERT_EQ(ts.size(), 1u);
|
|
EXPECT_DOUBLE_EQ(ts[0], 1234.5);
|
|
}
|
|
|
|
// This is the failure UDPSourceSession.cpp:560 documents. The kernel delivers
|
|
// two queued datagrams microseconds apart even though each carries 10 ms of
|
|
// signal. Dating from arrival crams the second packet's samples into that gap
|
|
// and the trace becomes a sawtooth; dating from the producer hrt does not.
|
|
TEST(FrameDecoder, AccumulatedScalarSurvivesBurstyDelivery) {
|
|
FrameDecoder dec;
|
|
SignalMeta m;
|
|
m.name = "Acc";
|
|
m.typeCode = 9;
|
|
m.numRows = 1;
|
|
m.samplingRate = 1000.0; /* 1 kHz, 10 samples = 10 ms per packet */
|
|
dec.setSignals({m});
|
|
|
|
const double ticks = 1.0e9;
|
|
std::vector<double> all;
|
|
|
|
for (int p = 0; p < 40; p++) {
|
|
FrameBuilder fb;
|
|
fb.addSignal(std::vector<double>(10, static_cast<double>(p)));
|
|
const double producerSec = 100.0 + p * 0.010;
|
|
/* Packets 20+ arrive in a burst, all within 50 us of each other. */
|
|
const double arrival = (p < 20) ? (500.0 + p * 0.010)
|
|
: (500.2 + (p - 20) * 0.00005);
|
|
const FrameView& f = fb.build(static_cast<uint64_t>(producerSec * ticks),
|
|
arrival, 10, static_cast<uint32_t>(p + 1));
|
|
dec.beginFrame(f);
|
|
std::vector<double> ts;
|
|
if (dec.timestamps(f, 0, ts)) {
|
|
all.insert(all.end(), ts.begin(), ts.end());
|
|
}
|
|
}
|
|
|
|
ASSERT_GT(all.size(), 300u);
|
|
for (size_t i = 1; i < all.size(); i++) {
|
|
EXPECT_GT(all[i], all[i - 1]) << "non-monotonic at " << i;
|
|
EXPECT_NEAR(all[i] - all[i - 1], 0.001, 2e-4)
|
|
<< "spacing collapsed at " << i << " (sawtooth)";
|
|
}
|
|
}
|
|
|
|
namespace {
|
|
|
|
/** Ten contiguous 10-sample bursts at 1 kHz, counters 1..10, ending at 500.090. */
|
|
SignalMeta accSignal() {
|
|
SignalMeta m;
|
|
m.name = "Acc";
|
|
m.typeCode = 9;
|
|
m.numRows = 1;
|
|
m.samplingRate = 1000.0; /* 10 samples = 10 ms per packet */
|
|
return m;
|
|
}
|
|
|
|
void primeTenBursts(FrameDecoder& dec, std::vector<double>& ts, bool withCounter) {
|
|
for (int p = 0; p < 10; p++) {
|
|
FrameBuilder fb;
|
|
fb.addSignal(std::vector<double>(10, 1.0));
|
|
const FrameView& f = fb.build(0, 500.0 + p * 0.010, 10,
|
|
withCounter ? static_cast<uint32_t>(p + 1) : 0u);
|
|
dec.beginFrame(f);
|
|
ASSERT_TRUE(dec.timestamps(f, 0, ts));
|
|
}
|
|
ASSERT_NEAR(ts[9], 500.090, 1e-9);
|
|
}
|
|
|
|
} /* namespace */
|
|
|
|
// The counterweight to the test above. Chaining bursts to suppress arrival
|
|
// jitter is only safe if loss is accounted for: a bare chain closes the hole a
|
|
// dropped datagram left and dates every later sample early for the rest of the
|
|
// run. The wire says exactly how much is missing, so no estimate is needed —
|
|
// and this test deliberately makes arrival time a LIAR (200 ms off) to prove
|
|
// the reconstruction comes from the counter and not from when the packet landed.
|
|
TEST(FrameDecoder, AccumulatedScalarReinstatesLostPacketsFromTheCounterGap) {
|
|
FrameDecoder dec;
|
|
dec.setSignals({accSignal()});
|
|
std::vector<double> ts;
|
|
primeTenBursts(dec, ts, /*withCounter=*/true);
|
|
|
|
/* Counter 111 after 10: 100 packets lost, 1000 samples, exactly 1 s. The
|
|
* packet lands 200 ms later than that truth would predict. */
|
|
FrameBuilder fb;
|
|
fb.addSignal(std::vector<double>(10, 1.0));
|
|
const FrameView& f = fb.build(0, 501.300, 10, 111u);
|
|
dec.beginFrame(f);
|
|
ASSERT_TRUE(dec.timestamps(f, 0, ts));
|
|
|
|
/* Chaining blindly gives 500.091; anchoring on arrival gives 501.291. */
|
|
EXPECT_NEAR(ts[0], 501.091, 1e-9);
|
|
EXPECT_NEAR(ts[9], 501.100, 1e-9);
|
|
}
|
|
|
|
// A producer that never advances the counter, or restarts it, leaves nothing to
|
|
// reconstruct from. Arrival time is then the better of two bad answers, and the
|
|
// chain has to be abandoned rather than left to drift forever.
|
|
TEST(FrameDecoder, AccumulatedScalarResyncsOnArrivalWhenTheCounterSaysNothing) {
|
|
FrameDecoder dec;
|
|
dec.setSignals({accSignal()});
|
|
std::vector<double> ts;
|
|
primeTenBursts(dec, ts, /*withCounter=*/false);
|
|
|
|
FrameBuilder fb;
|
|
fb.addSignal(std::vector<double>(10, 1.0));
|
|
const FrameView& f = fb.build(0, 501.100, 10, 0u);
|
|
dec.beginFrame(f);
|
|
ASSERT_TRUE(dec.timestamps(f, 0, ts));
|
|
|
|
EXPECT_NEAR(ts[0], 501.091, 1e-9);
|
|
EXPECT_NEAR(ts[9], 501.100, 1e-9);
|
|
}
|
|
|
|
// Re-anchoring must never move a signal's timestamps backwards: the ring, the
|
|
// trigger and the exporter all assume they increase, and a backward step is
|
|
// indistinguishable from corruption downstream. Here the counter claims a
|
|
// 20 s hole while the packet arrives 10 ms after the last one, so the
|
|
// prediction and arrival disagree wildly and arrival points into the past.
|
|
TEST(FrameDecoder, AccumulatedScalarNeverStepsBackwardsWhenResyncing) {
|
|
FrameDecoder dec;
|
|
dec.setSignals({accSignal()});
|
|
std::vector<double> ts;
|
|
primeTenBursts(dec, ts, /*withCounter=*/true);
|
|
const double prevEnd = ts[9];
|
|
|
|
FrameBuilder fb;
|
|
fb.addSignal(std::vector<double>(10, 1.0));
|
|
const FrameView& f = fb.build(0, 500.000, 10, 2010u);
|
|
dec.beginFrame(f);
|
|
ASSERT_TRUE(dec.timestamps(f, 0, ts));
|
|
|
|
EXPECT_GT(ts[0], prevEnd) << "resync stepped backwards over the previous burst";
|
|
for (size_t i = 1; i < ts.size(); i++) {
|
|
EXPECT_GT(ts[i], ts[i - 1]);
|
|
}
|
|
}
|
|
|
|
TEST(FrameDecoder, AccumulatedScalarDerivesDtFromTheHrtGapWhenNoRateIsDeclared) {
|
|
FrameDecoder dec;
|
|
SignalMeta m;
|
|
m.name = "Acc";
|
|
m.typeCode = 9;
|
|
m.samplingRate = 0.0; /* undeclared */
|
|
dec.setSignals({m});
|
|
|
|
const double ticks = 1.0e9;
|
|
std::vector<double> last;
|
|
for (int p = 0; p < 40; p++) {
|
|
FrameBuilder fb;
|
|
fb.addSignal(std::vector<double>(10, 1.0));
|
|
const double producerSec = 100.0 + p * 0.010; /* 10 ms per packet */
|
|
/* Zero-mean arrival jitter, so the rate fit still converges but any
|
|
* single arrival GAP is wrong. Without it, uniform arrivals make
|
|
* packetBurst and the hrt path return the same number and the test
|
|
* cannot tell which branch produced it. The last packet's gap is
|
|
* 7 ms, which arrival-spanning would render as a 0.7 ms period. */
|
|
const double jitter[4] = {0.0, 0.003, 0.0, -0.003};
|
|
const FrameView& f = fb.build(static_cast<uint64_t>(producerSec * ticks),
|
|
700.0 + p * 0.010 + jitter[p % 4], 10,
|
|
static_cast<uint32_t>(p + 1));
|
|
dec.beginFrame(f);
|
|
std::vector<double> ts;
|
|
if (dec.timestamps(f, 0, ts)) { last = ts; }
|
|
}
|
|
|
|
ASSERT_EQ(last.size(), 10u);
|
|
/* 10 ms of producer time across 10 samples is a 1 ms period, whatever the
|
|
* datagrams did on the way over. */
|
|
EXPECT_NEAR(last[1] - last[0], 0.001, 1e-5);
|
|
}
|
|
|
|
// A PACKET burst has no per-element time at all. Elements span
|
|
// (lastPacket, thisPacket] — backwards from arrival, because the samples were
|
|
// acquired before the packet landed. Forward extrapolation would let a jittered
|
|
// packet overlap the next one and break ring monotonicity.
|
|
TEST(FrameDecoder, PacketBurstDropsTheFirstFrameThenSpansBackwards) {
|
|
FrameDecoder dec;
|
|
dec.setSignals({burst("Raw", kTimePacket, 0.0, 5, kNoTimeSignal)});
|
|
|
|
FrameBuilder fb1;
|
|
fb1.addSignal({1.0, 2.0, 3.0, 4.0, 5.0});
|
|
const FrameView& f1 = fb1.build(0, 10.0);
|
|
dec.beginFrame(f1);
|
|
std::vector<double> ts;
|
|
EXPECT_FALSE(dec.timestamps(f1, 0, ts))
|
|
<< "the first packet has no previous arrival to span from";
|
|
|
|
FrameBuilder fb2;
|
|
fb2.addSignal({6.0, 7.0, 8.0, 9.0, 10.0});
|
|
const FrameView& f2 = fb2.build(0, 10.05);
|
|
dec.beginFrame(f2);
|
|
ASSERT_TRUE(dec.timestamps(f2, 0, ts));
|
|
ASSERT_EQ(ts.size(), 5u);
|
|
EXPECT_GT(ts[0], 10.0);
|
|
EXPECT_NEAR(ts[4], 10.05, 1e-12);
|
|
EXPECT_NEAR(ts[1] - ts[0], 0.01, 1e-12);
|
|
}
|
|
|
|
TEST(FrameDecoder, PacketBurstStaysMonotonicUnderJitteredArrivals) {
|
|
FrameDecoder dec;
|
|
dec.setSignals({burst("Raw", kTimePacket, 0.0, 8, kNoTimeSignal)});
|
|
|
|
const double jitter[] = {0.0, 0.004, -0.003, 0.006, -0.002, 0.0, 0.005, -0.004};
|
|
std::vector<double> all;
|
|
for (int p = 0; p < 8; p++) {
|
|
FrameBuilder fb;
|
|
fb.addSignal(std::vector<double>(8, 1.0));
|
|
const FrameView& f = fb.build(0, 20.0 + p * 0.05 + jitter[p]);
|
|
dec.beginFrame(f);
|
|
std::vector<double> ts;
|
|
if (dec.timestamps(f, 0, ts)) {
|
|
all.insert(all.end(), ts.begin(), ts.end());
|
|
}
|
|
}
|
|
|
|
ASSERT_GT(all.size(), 8u);
|
|
for (size_t i = 1; i < all.size(); i++) {
|
|
EXPECT_GT(all[i], all[i - 1]) << "packets overlapped at " << i;
|
|
}
|
|
}
|
|
|
|
TEST(FrameDecoder, ResetForgetsPerSignalHistory) {
|
|
FrameDecoder dec;
|
|
dec.setSignals({burst("Raw", kTimePacket, 0.0, 4, kNoTimeSignal)});
|
|
|
|
FrameBuilder fb;
|
|
fb.addSignal({1.0, 2.0, 3.0, 4.0});
|
|
const FrameView& f = fb.build(0, 5.0);
|
|
dec.beginFrame(f);
|
|
std::vector<double> ts;
|
|
EXPECT_FALSE(dec.timestamps(f, 0, ts));
|
|
|
|
const FrameView& f2 = fb.build(0, 5.1);
|
|
dec.beginFrame(f2);
|
|
EXPECT_TRUE(dec.timestamps(f2, 0, ts));
|
|
|
|
dec.reset();
|
|
const FrameView& f3 = fb.build(0, 5.2);
|
|
dec.beginFrame(f3);
|
|
EXPECT_FALSE(dec.timestamps(f3, 0, ts))
|
|
<< "after reset the next packet is again the first one";
|
|
}
|