Merge "Handle one node going away better"
diff --git a/aos/network/multinode_timestamp_filter.cc b/aos/network/multinode_timestamp_filter.cc
index bc11ffc..f436bb0 100644
--- a/aos/network/multinode_timestamp_filter.cc
+++ b/aos/network/multinode_timestamp_filter.cc
@@ -637,9 +637,9 @@
timestamp_mappers_ = std::move(timestamp_mappers);
}
-TimeComparison CompareTimes(const std::vector<monotonic_clock::time_point> &ta,
- const std::vector<monotonic_clock::time_point> &tb,
- bool ignore_min_time) {
+TimeComparison CompareTimes(
+ const std::vector<monotonic_clock::time_point> &ta,
+ const std::vector<monotonic_clock::time_point> &tb) {
if (ta.size() != tb.size() || ta.empty()) {
return TimeComparison::kInvalid;
}
@@ -648,7 +648,8 @@
bool is_eq = true;
bool some_eq = false;
for (size_t i = 0; i < ta.size(); ++i) {
- if (ignore_min_time && tb[i] == monotonic_clock::min_time) {
+ if (tb[i] == monotonic_clock::min_time ||
+ ta[i] == monotonic_clock::min_time) {
continue;
}
if (ta[i] < tb[i]) {
@@ -693,7 +694,8 @@
chrono::nanoseconds dt;
for (size_t i = 0; i < ta.size(); ++i) {
// Skip any invalid timestamps.
- if (tb[i] == monotonic_clock::min_time) {
+ if (ta[i] == monotonic_clock::min_time ||
+ tb[i] == monotonic_clock::min_time) {
continue;
}
@@ -1074,7 +1076,7 @@
continue;
}
- switch (CompareTimes(result_times, solution, false)) {
+ switch (CompareTimes(result_times, solution)) {
// The old solution is before or at the new solution. This means that
// the old solution is a better result, so ignore this one.
case TimeComparison::kBefore:
@@ -1248,11 +1250,15 @@
// want to consume it. But, if this is the first time around, we want to
// re-solve by recursing (once) to pickup the better base.
- TimeComparison compare = CompareTimes(last_monotonics_, result_times, true);
+ TimeComparison compare = CompareTimes(last_monotonics_, result_times);
switch (compare) {
case TimeComparison::kBefore:
break;
case TimeComparison::kAfter:
+ problem.Debug();
+ for (size_t i = 0; i < result_times.size(); ++i) {
+ LOG(INFO) << " " << last_monotonics_[i] << " vs " << result_times[i];
+ }
LOG(FATAL) << "Found a solution before the last returned solution.";
break;
case TimeComparison::kEq:
diff --git a/aos/network/multinode_timestamp_filter.h b/aos/network/multinode_timestamp_filter.h
index b9467ec..0c07850 100644
--- a/aos/network/multinode_timestamp_filter.h
+++ b/aos/network/multinode_timestamp_filter.h
@@ -256,8 +256,7 @@
// Compares two sets of times, optionally ignoring times that are min_time
TimeComparison CompareTimes(const std::vector<monotonic_clock::time_point> &ta,
- const std::vector<monotonic_clock::time_point> &tb,
- bool ignore_min_time);
+ const std::vector<monotonic_clock::time_point> &tb);
// Returns the maximum amount of elapsed time between the two samples in time.
std::chrono::nanoseconds MaxElapsedTime(
diff --git a/aos/network/multinode_timestamp_filter_test.cc b/aos/network/multinode_timestamp_filter_test.cc
index b2eaf0f..54ce35f 100644
--- a/aos/network/multinode_timestamp_filter_test.cc
+++ b/aos/network/multinode_timestamp_filter_test.cc
@@ -167,45 +167,40 @@
std::vector<monotonic_clock::time_point> times_b = {time_list.begin() + 1u,
time_list.end()};
- CHECK_EQ(static_cast<int>(CompareTimes(times_a, times_b, true)),
- static_cast<int>(TimeComparison::kBefore));
- CHECK_EQ(static_cast<int>(CompareTimes(times_a, times_b, false)),
+ CHECK_EQ(static_cast<int>(CompareTimes(times_a, times_b)),
static_cast<int>(TimeComparison::kBefore));
- CHECK_EQ(static_cast<int>(CompareTimes(times_b, times_a, true)),
- static_cast<int>(TimeComparison::kAfter));
- CHECK_EQ(static_cast<int>(CompareTimes(times_b, times_a, false)),
+ CHECK_EQ(static_cast<int>(CompareTimes(times_b, times_a)),
static_cast<int>(TimeComparison::kAfter));
- CHECK_EQ(static_cast<int>(CompareTimes(times_a, times_a, true)),
- static_cast<int>(TimeComparison::kEq));
- CHECK_EQ(static_cast<int>(CompareTimes(times_b, times_b, false)),
+ CHECK_EQ(static_cast<int>(CompareTimes(times_a, times_a)),
static_cast<int>(TimeComparison::kEq));
+ // Now try one of the times being min_time.
std::vector<monotonic_clock::time_point> times_b_min = times_b;
times_b_min[5] = monotonic_clock::min_time;
- CHECK_EQ(static_cast<int>(CompareTimes(times_a, times_b_min, true)),
+ CHECK_EQ(static_cast<int>(CompareTimes(times_a, times_b_min)),
static_cast<int>(TimeComparison::kBefore));
- CHECK_EQ(static_cast<int>(CompareTimes(times_a, times_b_min, false)),
- static_cast<int>(TimeComparison::kInvalid));
+ CHECK_EQ(static_cast<int>(CompareTimes(times_b_min, times_a)),
+ static_cast<int>(TimeComparison::kAfter));
// Test if one of the elements is equal
std::vector<monotonic_clock::time_point> times_b_some_eq = times_b_min;
times_b_some_eq[2] = times_a[2];
- CHECK_EQ(static_cast<int>(CompareTimes(times_a, times_b_some_eq, true)),
+ CHECK_EQ(static_cast<int>(CompareTimes(times_a, times_b_some_eq)),
static_cast<int>(TimeComparison::kInvalid));
- CHECK_EQ(static_cast<int>(CompareTimes(times_b, times_b_some_eq, false)),
+ CHECK_EQ(static_cast<int>(CompareTimes(times_b_some_eq, times_a)),
static_cast<int>(TimeComparison::kInvalid));
// Test if elements are out of order
std::vector<monotonic_clock::time_point> times_b_mixed = times_b_min;
times_b_mixed[3] = times_a[0];
- CHECK_EQ(static_cast<int>(CompareTimes(times_a, times_b_mixed, true)),
+ CHECK_EQ(static_cast<int>(CompareTimes(times_a, times_b_mixed)),
static_cast<int>(TimeComparison::kInvalid));
- CHECK_EQ(static_cast<int>(CompareTimes(times_b, times_b_mixed, false)),
+ CHECK_EQ(static_cast<int>(CompareTimes(times_b_mixed, times_a)),
static_cast<int>(TimeComparison::kInvalid));
CHECK_EQ(InvalidDistance(times_a, times_a).count(), 0);