Use overloading instead of default values
As we are getting ready to add the send boot UUID everywhere, that will
require a UUID as an argument to all the Send methods with a default
that is event_loop_->boot_uuid(). That doesn't work. Instead, use
overloading to achieve the same purpose.
There are few call sites for all of these, so it isn't hard to change
them all.
Change-Id: Id1e17bbef2e63c72fa6ad2b038c69d452610e86e
diff --git a/aos/events/event_loop.h b/aos/events/event_loop.h
index b8f8d2d..22f7c6f 100644
--- a/aos/events/event_loop.h
+++ b/aos/events/event_loop.h
@@ -147,21 +147,18 @@
// get the sent times instead.
virtual void *data() = 0;
virtual size_t size() = 0;
- bool Send(size_t size,
- aos::monotonic_clock::time_point monotonic_remote_time =
- aos::monotonic_clock::min_time,
- aos::realtime_clock::time_point realtime_remote_time =
- aos::realtime_clock::min_time,
- uint32_t remote_queue_index = 0xffffffffu);
+ bool Send(size_t size);
+ bool Send(size_t size, monotonic_clock::time_point monotonic_remote_time,
+ realtime_clock::time_point realtime_remote_time,
+ uint32_t remote_queue_index);
// Sends a single block of data by copying it.
// The remote arguments have the same meaning as in Send above.
+ bool Send(const void *data, size_t size);
bool Send(const void *data, size_t size,
- aos::monotonic_clock::time_point monotonic_remote_time =
- aos::monotonic_clock::min_time,
- aos::realtime_clock::time_point realtime_remote_time =
- aos::realtime_clock::min_time,
- uint32_t remote_queue_index = 0xffffffffu);
+ monotonic_clock::time_point monotonic_remote_time,
+ realtime_clock::time_point realtime_remote_time,
+ uint32_t remote_queue_index);
const Channel *channel() const { return channel_; }
@@ -190,10 +187,8 @@
protected:
EventLoop *event_loop() { return event_loop_; }
- aos::monotonic_clock::time_point monotonic_sent_time_ =
- aos::monotonic_clock::min_time;
- aos::realtime_clock::time_point realtime_sent_time_ =
- aos::realtime_clock::min_time;
+ monotonic_clock::time_point monotonic_sent_time_ = monotonic_clock::min_time;
+ realtime_clock::time_point realtime_sent_time_ = realtime_clock::min_time;
uint32_t sent_queue_index_ = 0xffffffff;
private:
diff --git a/aos/events/event_loop_param_test.cc b/aos/events/event_loop_param_test.cc
index 79f326d..e0c6024 100644
--- a/aos/events/event_loop_param_test.cc
+++ b/aos/events/event_loop_param_test.cc
@@ -1848,6 +1848,7 @@
aos::monotonic_clock::time_point(chrono::seconds(1501));
const aos::realtime_clock::time_point realtime_remote_time =
aos::realtime_clock::time_point(chrono::seconds(3132));
+ const uint32_t remote_queue_index = 0x254971;
std::unique_ptr<aos::RawSender> sender =
loop1->MakeRawSender(configuration::GetChannel(
@@ -1859,18 +1860,20 @@
loop2->OnRun([&]() {
EXPECT_TRUE(sender->Send(kData.data(), kData.size(), monotonic_remote_time,
- realtime_remote_time));
+ realtime_remote_time, remote_queue_index));
});
bool happened = false;
loop2->MakeRawWatcher(
configuration::GetChannel(loop2->configuration(), "/test",
"aos.TestMessage", "", nullptr),
- [this, monotonic_remote_time, realtime_remote_time, &fetcher, &happened](
- const Context &context, const void * /*message*/) {
+ [this, monotonic_remote_time, realtime_remote_time,
+ remote_queue_index, &fetcher,
+ &happened](const Context &context, const void * /*message*/) {
happened = true;
EXPECT_EQ(monotonic_remote_time, context.monotonic_remote_time);
EXPECT_EQ(realtime_remote_time, context.realtime_remote_time);
+ EXPECT_EQ(remote_queue_index, context.remote_queue_index);
ASSERT_TRUE(fetcher->Fetch());
EXPECT_EQ(monotonic_remote_time,
diff --git a/aos/events/event_loop_tmpl.h b/aos/events/event_loop_tmpl.h
index 06b1643..74d3493 100644
--- a/aos/events/event_loop_tmpl.h
+++ b/aos/events/event_loop_tmpl.h
@@ -129,6 +129,11 @@
return false;
}
+inline bool RawSender::Send(size_t size) {
+ return Send(size, monotonic_clock::min_time, realtime_clock::min_time,
+ 0xffffffffu);
+}
+
inline bool RawSender::Send(
size_t size, aos::monotonic_clock::time_point monotonic_remote_time,
aos::realtime_clock::time_point realtime_remote_time,
@@ -147,6 +152,11 @@
return false;
}
+inline bool RawSender::Send(const void *data, size_t size) {
+ return Send(data, size, monotonic_clock::min_time, realtime_clock::min_time,
+ 0xffffffffu);
+}
+
inline bool RawSender::Send(
const void *data, size_t size,
aos::monotonic_clock::time_point monotonic_remote_time,
diff --git a/aos/ipc_lib/lockless_queue.cc b/aos/ipc_lib/lockless_queue.cc
index 2b704ef..a0c68cb 100644
--- a/aos/ipc_lib/lockless_queue.cc
+++ b/aos/ipc_lib/lockless_queue.cc
@@ -906,29 +906,27 @@
bool LocklessQueueSender::Send(
const char *data, size_t length,
- aos::monotonic_clock::time_point monotonic_remote_time,
- aos::realtime_clock::time_point realtime_remote_time,
+ monotonic_clock::time_point monotonic_remote_time,
+ realtime_clock::time_point realtime_remote_time,
uint32_t remote_queue_index,
- aos::monotonic_clock::time_point *monotonic_sent_time,
- aos::realtime_clock::time_point *realtime_sent_time,
- uint32_t *queue_index) {
+ monotonic_clock::time_point *monotonic_sent_time,
+ realtime_clock::time_point *realtime_sent_time, uint32_t *queue_index) {
CHECK_LE(length, size());
// Flatbuffers write from the back of the buffer to the front. If we are
// going to write an explicit chunk of memory into the buffer, we need to
// adhere to this convention and place it at the end.
memcpy((reinterpret_cast<char *>(Data()) + size() - length), data, length);
return Send(length, monotonic_remote_time, realtime_remote_time,
- remote_queue_index, monotonic_sent_time, realtime_sent_time,
- queue_index);
+ remote_queue_index, monotonic_sent_time,
+ realtime_sent_time, queue_index);
}
bool LocklessQueueSender::Send(
- size_t length, aos::monotonic_clock::time_point monotonic_remote_time,
- aos::realtime_clock::time_point realtime_remote_time,
+ size_t length, monotonic_clock::time_point monotonic_remote_time,
+ realtime_clock::time_point realtime_remote_time,
uint32_t remote_queue_index,
- aos::monotonic_clock::time_point *monotonic_sent_time,
- aos::realtime_clock::time_point *realtime_sent_time,
- uint32_t *queue_index) {
+ monotonic_clock::time_point *monotonic_sent_time,
+ realtime_clock::time_point *realtime_sent_time, uint32_t *queue_index) {
const size_t queue_size = memory_->queue_size();
CHECK_LE(length, size());
@@ -1207,11 +1205,12 @@
LocklessQueueReader::Result LocklessQueueReader::Read(
uint32_t uint32_queue_index,
- ::aos::monotonic_clock::time_point *monotonic_sent_time,
- ::aos::realtime_clock::time_point *realtime_sent_time,
- ::aos::monotonic_clock::time_point *monotonic_remote_time,
- ::aos::realtime_clock::time_point *realtime_remote_time,
- uint32_t *remote_queue_index, size_t *length, char *data) const {
+ monotonic_clock::time_point *monotonic_sent_time,
+ realtime_clock::time_point *realtime_sent_time,
+ monotonic_clock::time_point *monotonic_remote_time,
+ realtime_clock::time_point *realtime_remote_time,
+ uint32_t *remote_queue_index, size_t *length,
+ char *data) const {
const size_t queue_size = memory_->queue_size();
// Build up the QueueIndex.
diff --git a/aos/ipc_lib/lockless_queue.h b/aos/ipc_lib/lockless_queue.h
index a5de6cc..69207f4 100644
--- a/aos/ipc_lib/lockless_queue.h
+++ b/aos/ipc_lib/lockless_queue.h
@@ -82,12 +82,12 @@
// Timestamp of the message. Needs to be monotonically incrementing in the
// queue, which means that time needs to be re-sampled every time a write
// fails.
- ::aos::monotonic_clock::time_point monotonic_sent_time;
- ::aos::realtime_clock::time_point realtime_sent_time;
+ monotonic_clock::time_point monotonic_sent_time;
+ realtime_clock::time_point realtime_sent_time;
// Timestamps of the message from the remote node. These are transparently
// passed through.
- ::aos::monotonic_clock::time_point monotonic_remote_time;
- ::aos::realtime_clock::time_point realtime_remote_time;
+ monotonic_clock::time_point monotonic_remote_time;
+ realtime_clock::time_point realtime_remote_time;
// Queue index from the remote node.
uint32_t remote_queue_index;
@@ -303,26 +303,21 @@
// Note: calls to Data() are expensive enough that you should cache it.
size_t size() const;
void *Data();
- bool Send(size_t length,
- aos::monotonic_clock::time_point monotonic_remote_time =
- aos::monotonic_clock::min_time,
- aos::realtime_clock::time_point realtime_remote_time =
- aos::realtime_clock::min_time,
- uint32_t remote_queue_index = 0xffffffff,
- aos::monotonic_clock::time_point *monotonic_sent_time = nullptr,
- aos::realtime_clock::time_point *realtime_sent_time = nullptr,
+ bool Send(size_t length, monotonic_clock::time_point monotonic_remote_time,
+ realtime_clock::time_point realtime_remote_time,
+ uint32_t remote_queue_index,
+ monotonic_clock::time_point *monotonic_sent_time = nullptr,
+ realtime_clock::time_point *realtime_sent_time = nullptr,
uint32_t *queue_index = nullptr);
// Sends up to length data. Does not wakeup the target.
bool Send(const char *data, size_t length,
- aos::monotonic_clock::time_point monotonic_remote_time =
- aos::monotonic_clock::min_time,
- aos::realtime_clock::time_point realtime_remote_time =
- aos::realtime_clock::min_time,
- uint32_t remote_queue_index = 0xffffffff,
- aos::monotonic_clock::time_point *monotonic_sent_time = nullptr,
- aos::realtime_clock::time_point *realtime_sent_time = nullptr,
- uint32_t *queue_index = nullptr);
+ monotonic_clock::time_point monotonic_remote_time,
+ realtime_clock::time_point realtime_remote_time,
+ uint32_t remote_queue_index,
+ monotonic_clock::time_point *monotonic_sent_time,
+ realtime_clock::time_point *realtime_sent_time,
+ uint32_t *queue_index);
int buffer_index() const;
@@ -401,11 +396,12 @@
//
// data may be nullptr to indicate the data should not be copied.
Result Read(uint32_t queue_index,
- ::aos::monotonic_clock::time_point *monotonic_sent_time,
- ::aos::realtime_clock::time_point *realtime_sent_time,
- ::aos::monotonic_clock::time_point *monotonic_remote_time,
- ::aos::realtime_clock::time_point *realtime_remote_time,
- uint32_t *remote_queue_index, size_t *length, char *data) const;
+ monotonic_clock::time_point *monotonic_sent_time,
+ realtime_clock::time_point *realtime_sent_time,
+ monotonic_clock::time_point *monotonic_remote_time,
+ realtime_clock::time_point *realtime_remote_time,
+ uint32_t *remote_queue_index,
+ size_t *length, char *data) const;
// Returns the index to the latest queue message. Returns empty_queue_index()
// if there are no messages in the queue. Do note that this index wraps if
diff --git a/aos/ipc_lib/lockless_queue_death_test.cc b/aos/ipc_lib/lockless_queue_death_test.cc
index b4bb66a..346f88e 100644
--- a/aos/ipc_lib/lockless_queue_death_test.cc
+++ b/aos/ipc_lib/lockless_queue_death_test.cc
@@ -533,7 +533,9 @@
for (int i = 0; i < 5; ++i) {
char data[100];
size_t s = snprintf(data, sizeof(data), "foobar%d", i + 1);
- sender.Send(data, s + 1);
+ sender.Send(data, s + 1, monotonic_clock::min_time,
+ realtime_clock::min_time, 0xffffffffl,
+ nullptr, nullptr, nullptr);
// Pin a message, so when we keep writing we will exercise the pinning
// logic.
if (i == 1) {
@@ -605,7 +607,9 @@
// Send a message to make sure that the queue still works.
char data[100];
size_t s = snprintf(data, sizeof(data), "foobar%d", 971);
- sender.Send(data, s + 1);
+ sender.Send(data, s + 1, monotonic_clock::min_time,
+ realtime_clock::min_time, 0xffffffffl,
+ nullptr, nullptr, nullptr);
}
// Now loop through the queue and make sure the number in the snprintf
@@ -613,10 +617,10 @@
char last_data = '0';
int i = 0;
while (true) {
- ::aos::monotonic_clock::time_point monotonic_sent_time;
- ::aos::realtime_clock::time_point realtime_sent_time;
- ::aos::monotonic_clock::time_point monotonic_remote_time;
- ::aos::realtime_clock::time_point realtime_remote_time;
+ monotonic_clock::time_point monotonic_sent_time;
+ realtime_clock::time_point realtime_sent_time;
+ monotonic_clock::time_point monotonic_remote_time;
+ realtime_clock::time_point realtime_remote_time;
uint32_t remote_queue_index;
char read_data[1024];
size_t length;
diff --git a/aos/ipc_lib/lockless_queue_test.cc b/aos/ipc_lib/lockless_queue_test.cc
index a90b976..c8f3d23 100644
--- a/aos/ipc_lib/lockless_queue_test.cc
+++ b/aos/ipc_lib/lockless_queue_test.cc
@@ -238,17 +238,18 @@
// Send a trivial piece of data.
char data[100];
size_t s = snprintf(data, sizeof(data), "foobar%d", i);
- sender.Send(data, s);
+ sender.Send(data, s, monotonic_clock::min_time, realtime_clock::min_time,
+ 0xffffffffu, nullptr, nullptr, nullptr);
// Confirm that the queue index still makes sense. This is easier since the
// empty case has been handled.
EXPECT_EQ(reader.LatestIndex().index(), i);
// Read a result from 5 in the past.
- ::aos::monotonic_clock::time_point monotonic_sent_time;
- ::aos::realtime_clock::time_point realtime_sent_time;
- ::aos::monotonic_clock::time_point monotonic_remote_time;
- ::aos::realtime_clock::time_point realtime_remote_time;
+ monotonic_clock::time_point monotonic_sent_time;
+ realtime_clock::time_point realtime_sent_time;
+ monotonic_clock::time_point monotonic_remote_time;
+ realtime_clock::time_point realtime_remote_time;
uint32_t remote_queue_index;
char read_data[1024];
size_t length;
diff --git a/aos/ipc_lib/queue_racer.cc b/aos/ipc_lib/queue_racer.cc
index 5b3d88b..afd4135 100644
--- a/aos/ipc_lib/queue_racer.cc
+++ b/aos/ipc_lib/queue_racer.cc
@@ -177,7 +177,9 @@
}
++started_writes_;
- sender.Send(sizeof(ThreadPlusCount));
+ sender.Send(sizeof(ThreadPlusCount), aos::monotonic_clock::min_time,
+ aos::realtime_clock::min_time, 0xffffffff,
+ nullptr, nullptr, nullptr);
// Blank out the new scratch buffer, to catch other people using it.
{
char *const new_data = static_cast<char *>(sender.Data()) +
@@ -261,10 +263,10 @@
for (uint64_t i = initial_i;
i < (1 + write_wrap_count) * num_messages_ * num_threads_; ++i) {
- ::aos::monotonic_clock::time_point monotonic_sent_time;
- ::aos::realtime_clock::time_point realtime_sent_time;
- ::aos::monotonic_clock::time_point monotonic_remote_time;
- ::aos::realtime_clock::time_point realtime_remote_time;
+ monotonic_clock::time_point monotonic_sent_time;
+ realtime_clock::time_point realtime_sent_time;
+ monotonic_clock::time_point monotonic_remote_time;
+ realtime_clock::time_point realtime_remote_time;
uint32_t remote_queue_index;
size_t length;
char read_data[1024];