blob: 809539afbbdb6cb31070f5cf7374f9790685b3cc [file] [log] [blame]
Alex Perrycb7da4b2019-08-28 19:35:56 -07001#ifndef AOS_EVENTS_EVENT_LOOP_H_
2#define AOS_EVENTS_EVENT_LOOP_H_
3
Brian Silverman6a54ff32020-04-28 16:41:39 -07004#include <sched.h>
5
Alex Perrycb7da4b2019-08-28 19:35:56 -07006#include <atomic>
milind1f1dca32021-07-03 13:50:07 -07007#include <ostream>
Alex Perrycb7da4b2019-08-28 19:35:56 -07008#include <string>
James Kuszmaul3ae42262019-11-08 12:33:41 -08009#include <string_view>
Alex Perrycb7da4b2019-08-28 19:35:56 -070010
Austin Schuh3054f5f2021-07-21 15:38:01 -070011#include "absl/container/btree_set.h"
Alex Perrycb7da4b2019-08-28 19:35:56 -070012#include "aos/configuration.h"
13#include "aos/configuration_generated.h"
Austin Schuh1af273d2020-03-07 20:11:34 -080014#include "aos/events/channel_preallocated_allocator.h"
Austin Schuh7d87b672019-12-01 20:23:49 -080015#include "aos/events/event_loop_event.h"
Austin Schuh39788ff2019-12-01 18:22:57 -080016#include "aos/events/event_loop_generated.h"
17#include "aos/events/timing_statistics.h"
Alex Perrycb7da4b2019-08-28 19:35:56 -070018#include "aos/flatbuffers.h"
Brian Silverman79ec7fc2020-06-08 20:11:22 -050019#include "aos/ftrace.h"
Brian Silvermana1652f32020-01-29 20:41:44 -080020#include "aos/ipc_lib/data_alignment.h"
Alex Perrycb7da4b2019-08-28 19:35:56 -070021#include "aos/json_to_flatbuffer.h"
22#include "aos/time/time.h"
Austin Schuh39788ff2019-12-01 18:22:57 -080023#include "aos/util/phased_loop.h"
Austin Schuh4385b142021-03-14 21:31:13 -070024#include "aos/uuid.h"
Alex Perrycb7da4b2019-08-28 19:35:56 -070025#include "flatbuffers/flatbuffers.h"
26#include "glog/logging.h"
27
Austin Schuh39788ff2019-12-01 18:22:57 -080028DECLARE_bool(timing_reports);
29DECLARE_int32(timing_report_ms);
30
Alex Perrycb7da4b2019-08-28 19:35:56 -070031namespace aos {
32
Austin Schuh39788ff2019-12-01 18:22:57 -080033class EventLoop;
34class WatcherState;
35
Austin Schuh6231cc32019-12-07 13:06:15 -080036// Struct available on Watchers, Fetchers, Timers, and PhasedLoops with context
37// about the current message.
Alex Perrycb7da4b2019-08-28 19:35:56 -070038struct Context {
Austin Schuhad154822019-12-27 15:45:13 -080039 // Time that the message was sent on this node, or the timer was triggered.
40 monotonic_clock::time_point monotonic_event_time;
41 // Realtime the message was sent on this node. This is set to min_time for
42 // Timers and PhasedLoops.
43 realtime_clock::time_point realtime_event_time;
44
James Kuszmaulad523042022-10-05 16:47:33 -070045 // The rest are only valid for Watchers and Fetchers.
46
Austin Schuhad154822019-12-27 15:45:13 -080047 // For a single-node configuration, these two are identical to *_event_time.
48 // In a multinode configuration, these are the times that the message was
49 // sent on the original node.
50 monotonic_clock::time_point monotonic_remote_time;
51 realtime_clock::time_point realtime_remote_time;
52
Alex Perrycb7da4b2019-08-28 19:35:56 -070053 // Index in the queue.
54 uint32_t queue_index;
Austin Schuhad154822019-12-27 15:45:13 -080055 // Index into the remote queue. Useful to determine if data was lost. In a
56 // single-node configuration, this will match queue_index.
57 uint32_t remote_queue_index;
58
Alex Perrycb7da4b2019-08-28 19:35:56 -070059 // Size of the data sent.
60 size_t size;
61 // Pointer to the data.
Brian Silvermaneaa41d62020-07-08 19:47:35 -070062 const void *data;
Austin Schuh678078e2020-08-01 14:30:36 -070063
Brian Silverman4f4e0612020-08-12 19:54:41 -070064 // Index of the message buffer. This will be in [0, NumberBuffers) on
65 // read_method=PIN channels, and -1 for other channels.
66 //
67 // This only tells you about the underlying storage for this message, not
68 // anything about its position in the queue. This is only useful for advanced
69 // zero-copy use cases, on read_method=PIN channels.
70 //
71 // This will uniquely identify a message on this channel at a point in time.
72 // For senders, this point in time is while the sender has the message. With
73 // read_method==PIN, this point in time includes while the caller has access
74 // to this context. For other read_methods, this point in time may be before
75 // the caller has access to this context, which makes this pretty useless.
76 int buffer_index;
77
Austin Schuh8902fa52021-03-14 22:39:24 -070078 // UUID of the remote node which sent this message, or this node in the case
79 // of events which are local to this node.
Austin Schuha9012be2021-07-21 15:19:11 -070080 UUID source_boot_uuid = UUID::Zero();
Austin Schuh8902fa52021-03-14 22:39:24 -070081
Austin Schuhca75b6a2020-12-15 21:12:24 -080082 // Efficiently copies the flatbuffer into a FlatbufferVector, allocating
Austin Schuh678078e2020-08-01 14:30:36 -070083 // memory in the process. It is vital that T matches the type of the
84 // underlying flatbuffer.
85 template <typename T>
86 FlatbufferVector<T> CopyFlatBuffer() const {
Brian Silverman354697a2020-09-22 21:06:32 -070087 ResizeableBuffer buffer;
88 buffer.resize(size);
89 memcpy(buffer.data(), data, size);
90 return FlatbufferVector<T>(std::move(buffer));
Austin Schuh678078e2020-08-01 14:30:36 -070091 }
Alex Perrycb7da4b2019-08-28 19:35:56 -070092};
93
94// Raw version of fetcher. Contains a local variable that the fetcher will
95// update. This is used for reflection and as an interface to implement typed
96// fetchers.
97class RawFetcher {
98 public:
Austin Schuh39788ff2019-12-01 18:22:57 -080099 RawFetcher(EventLoop *event_loop, const Channel *channel);
Alex Perrycb7da4b2019-08-28 19:35:56 -0700100 RawFetcher(const RawFetcher &) = delete;
101 RawFetcher &operator=(const RawFetcher &) = delete;
Austin Schuh39788ff2019-12-01 18:22:57 -0800102 virtual ~RawFetcher();
Alex Perrycb7da4b2019-08-28 19:35:56 -0700103
Austin Schuh39788ff2019-12-01 18:22:57 -0800104 // Fetches the next message in the queue without blocking. Returns true if
105 // there was a new message and we got it.
106 bool FetchNext();
107
108 // Fetches the latest message without blocking.
109 bool Fetch();
110
111 // Returns the channel this fetcher uses.
112 const Channel *channel() const { return channel_; }
113 // Returns the context for the current message.
114 const Context &context() const { return context_; }
115
116 protected:
117 EventLoop *event_loop() { return event_loop_; }
Austin Schuh3054f5f2021-07-21 15:38:01 -0700118 const EventLoop *event_loop() const { return event_loop_; }
Austin Schuh39788ff2019-12-01 18:22:57 -0800119
Alex Perrycb7da4b2019-08-28 19:35:56 -0700120 Context context_;
Austin Schuh39788ff2019-12-01 18:22:57 -0800121
122 private:
123 friend class EventLoop;
124 // Implementation
125 virtual std::pair<bool, monotonic_clock::time_point> DoFetchNext() = 0;
126 virtual std::pair<bool, monotonic_clock::time_point> DoFetch() = 0;
127
Brian Silverman79ec7fc2020-06-08 20:11:22 -0500128 EventLoop *const event_loop_;
129 const Channel *const channel_;
130 const std::string ftrace_prefix_;
Austin Schuh39788ff2019-12-01 18:22:57 -0800131
132 internal::RawFetcherTiming timing_;
Brian Silverman79ec7fc2020-06-08 20:11:22 -0500133 Ftrace ftrace_;
Alex Perrycb7da4b2019-08-28 19:35:56 -0700134};
135
136// Raw version of sender. Sends a block of data. This is used for reflection
137// and as a building block to implement typed senders.
138class RawSender {
139 public:
Tyler Chatowb7c6eba2021-07-28 14:43:23 -0700140 using SharedSpan = std::shared_ptr<const absl::Span<const uint8_t>>;
141
Brian Silverman183859c2022-05-14 02:03:06 -0700142 // This looks a little ugly with no space, but please leave it so clang-format
143 // doesn't keep changing it. Bug is filed at
144 // <https://github.com/llvm/llvm-project/issues/55457>.
145 enum class [[nodiscard]] Error{
milind1f1dca32021-07-03 13:50:07 -0700146 // Represents success and no error
147 kOk,
148
149 // Error for messages on channels being sent faster than their
150 // frequency and channel storage duration allow
Eric Schmiedebergef44b8a2022-02-28 17:30:38 -0700151 kMessagesSentTooFast,
152 // Access to Redzone was attempted in Sender Queue
Brian Silverman183859c2022-05-14 02:03:06 -0700153 kInvalidRedzone,
Eric Schmiedebergef44b8a2022-02-28 17:30:38 -0700154 };
milind1f1dca32021-07-03 13:50:07 -0700155
Austin Schuh39788ff2019-12-01 18:22:57 -0800156 RawSender(EventLoop *event_loop, const Channel *channel);
157 RawSender(const RawSender &) = delete;
158 RawSender &operator=(const RawSender &) = delete;
159
160 virtual ~RawSender();
Alex Perrycb7da4b2019-08-28 19:35:56 -0700161
Brian Silverman9809c5f2022-07-23 16:12:23 -0700162 // Returns the buffer to write new messages into. This is always valid, and
163 // may change after calling any of the Send functions.
Alex Perrycb7da4b2019-08-28 19:35:56 -0700164 virtual void *data() = 0;
165 virtual size_t size() = 0;
milind1f1dca32021-07-03 13:50:07 -0700166
167 // Sends a message without copying it. The users starts by copying up to
168 // size() bytes into the data backed by data(). They then call Send to send.
169 // Returns Error::kOk on a successful send, or
170 // Error::kMessagesSentTooFast if messages were sent too fast. If provided,
171 // monotonic_remote_time, realtime_remote_time, and remote_queue_index are
172 // attached to the message and are available in the context on the read side.
173 // If they are not populated, the read side will get the sent times instead.
174 Error Send(size_t size);
175 Error Send(size_t size, monotonic_clock::time_point monotonic_remote_time,
176 realtime_clock::time_point realtime_remote_time,
177 uint32_t remote_queue_index, const UUID &source_boot_uuid);
Alex Perrycb7da4b2019-08-28 19:35:56 -0700178
179 // Sends a single block of data by copying it.
Austin Schuhad154822019-12-27 15:45:13 -0800180 // The remote arguments have the same meaning as in Send above.
milind1f1dca32021-07-03 13:50:07 -0700181 // Returns Error::kMessagesSentTooFast if messages were sent too fast
182 Error Send(const void *data, size_t size);
183 Error Send(const void *data, size_t size,
184 monotonic_clock::time_point monotonic_remote_time,
185 realtime_clock::time_point realtime_remote_time,
186 uint32_t remote_queue_index, const UUID &source_boot_uuid);
187
188 // CHECKs that no sending Error occurred and logs the channel_ data if
189 // one did
190 void CheckOk(const Error err);
Alex Perrycb7da4b2019-08-28 19:35:56 -0700191
Tyler Chatowb7c6eba2021-07-28 14:43:23 -0700192 // Sends a single block of data by refcounting it to avoid copies. The data
193 // must not change after being passed into Send. The remote arguments have the
194 // same meaning as in Send above.
milind1f1dca32021-07-03 13:50:07 -0700195 Error Send(const SharedSpan data);
196 Error Send(const SharedSpan data,
197 monotonic_clock::time_point monotonic_remote_time,
198 realtime_clock::time_point realtime_remote_time,
199 uint32_t remote_queue_index, const UUID &remote_boot_uuid);
Tyler Chatowb7c6eba2021-07-28 14:43:23 -0700200
Austin Schuh54cf95f2019-11-29 13:14:18 -0800201 const Channel *channel() const { return channel_; }
202
Austin Schuhad154822019-12-27 15:45:13 -0800203 // Returns the time_points that the last message was sent at.
204 aos::monotonic_clock::time_point monotonic_sent_time() const {
205 return monotonic_sent_time_;
206 }
207 aos::realtime_clock::time_point realtime_sent_time() const {
208 return realtime_sent_time_;
209 }
210 // Returns the queue index that this was sent with.
211 uint32_t sent_queue_index() const { return sent_queue_index_; }
212
Brian Silvermana1652f32020-01-29 20:41:44 -0800213 // Returns the associated flatbuffers-style allocator. This must be
214 // deallocated before the message is sent.
Austin Schuh1af273d2020-03-07 20:11:34 -0800215 ChannelPreallocatedAllocator *fbb_allocator() {
216 fbb_allocator_ = ChannelPreallocatedAllocator(
217 reinterpret_cast<uint8_t *>(data()), size(), channel());
Brian Silvermana1652f32020-01-29 20:41:44 -0800218 return &fbb_allocator_;
219 }
220
Brian Silverman4f4e0612020-08-12 19:54:41 -0700221 // Index of the buffer which is currently exposed by data() and the various
222 // other accessors. This is the message the caller should be filling out.
223 virtual int buffer_index() = 0;
224
Alex Perrycb7da4b2019-08-28 19:35:56 -0700225 protected:
Austin Schuh39788ff2019-12-01 18:22:57 -0800226 EventLoop *event_loop() { return event_loop_; }
Austin Schuh3054f5f2021-07-21 15:38:01 -0700227 const EventLoop *event_loop() const { return event_loop_; }
Austin Schuh54cf95f2019-11-29 13:14:18 -0800228
Austin Schuhb5c6f972021-03-14 21:53:07 -0700229 monotonic_clock::time_point monotonic_sent_time_ = monotonic_clock::min_time;
230 realtime_clock::time_point realtime_sent_time_ = realtime_clock::min_time;
Austin Schuhad154822019-12-27 15:45:13 -0800231 uint32_t sent_queue_index_ = 0xffffffff;
232
Austin Schuh39788ff2019-12-01 18:22:57 -0800233 private:
234 friend class EventLoop;
235
milind1f1dca32021-07-03 13:50:07 -0700236 virtual Error DoSend(const void *data, size_t size,
237 monotonic_clock::time_point monotonic_remote_time,
238 realtime_clock::time_point realtime_remote_time,
239 uint32_t remote_queue_index,
240 const UUID &source_boot_uuid) = 0;
241 virtual Error DoSend(size_t size,
242 monotonic_clock::time_point monotonic_remote_time,
243 realtime_clock::time_point realtime_remote_time,
244 uint32_t remote_queue_index,
245 const UUID &source_boot_uuid) = 0;
246 virtual Error DoSend(const SharedSpan data,
247 monotonic_clock::time_point monotonic_remote_time,
248 realtime_clock::time_point realtime_remote_time,
249 uint32_t remote_queue_index,
250 const UUID &source_boot_uuid);
Austin Schuh39788ff2019-12-01 18:22:57 -0800251
James Kuszmaul93abac12022-04-14 15:05:10 -0700252 void RecordSendResult(const Error error, size_t message_size);
253
Brian Silverman79ec7fc2020-06-08 20:11:22 -0500254 EventLoop *const event_loop_;
255 const Channel *const channel_;
256 const std::string ftrace_prefix_;
Alex Perrycb7da4b2019-08-28 19:35:56 -0700257
Austin Schuh39788ff2019-12-01 18:22:57 -0800258 internal::RawSenderTiming timing_;
Brian Silverman79ec7fc2020-06-08 20:11:22 -0500259 Ftrace ftrace_;
Brian Silvermana1652f32020-01-29 20:41:44 -0800260
Austin Schuh1af273d2020-03-07 20:11:34 -0800261 ChannelPreallocatedAllocator fbb_allocator_{nullptr, 0, nullptr};
Austin Schuh39788ff2019-12-01 18:22:57 -0800262};
Alex Perrycb7da4b2019-08-28 19:35:56 -0700263
milind1f1dca32021-07-03 13:50:07 -0700264// Needed for compatibility with glog
265std::ostream &operator<<(std::ostream &os, const RawSender::Error err);
266
Alex Perrycb7da4b2019-08-28 19:35:56 -0700267// Fetches the newest message from a channel.
268// This provides a polling based interface for channels.
269template <typename T>
270class Fetcher {
271 public:
272 Fetcher() {}
273
274 // Fetches the next message. Returns true if it fetched a new message. This
275 // method will only return messages sent after the Fetcher was created.
Brian Silvermana1652f32020-01-29 20:41:44 -0800276 bool FetchNext() {
277 const bool result = fetcher_->FetchNext();
278 if (result) {
279 CheckChannelDataAlignment(fetcher_->context().data,
280 fetcher_->context().size);
281 }
282 return result;
283 }
Alex Perrycb7da4b2019-08-28 19:35:56 -0700284
285 // Fetches the most recent message. Returns true if it fetched a new message.
286 // This will return the latest message regardless of if it was sent before or
287 // after the fetcher was created.
Brian Silvermana1652f32020-01-29 20:41:44 -0800288 bool Fetch() {
289 const bool result = fetcher_->Fetch();
290 if (result) {
291 CheckChannelDataAlignment(fetcher_->context().data,
292 fetcher_->context().size);
293 }
294 return result;
295 }
Alex Perrycb7da4b2019-08-28 19:35:56 -0700296
297 // Returns a pointer to the contained flatbuffer, or nullptr if there is no
298 // available message.
299 const T *get() const {
Austin Schuh39788ff2019-12-01 18:22:57 -0800300 return fetcher_->context().data != nullptr
301 ? flatbuffers::GetRoot<T>(
302 reinterpret_cast<const char *>(fetcher_->context().data))
Alex Perrycb7da4b2019-08-28 19:35:56 -0700303 : nullptr;
304 }
305
Brian Silvermande9f3ff2020-04-28 16:56:58 -0700306 // Returns the channel this fetcher uses
307 const Channel *channel() const { return fetcher_->channel(); }
308
Alex Perrycb7da4b2019-08-28 19:35:56 -0700309 // Returns the context holding timestamps and other metadata about the
310 // message.
311 const Context &context() const { return fetcher_->context(); }
312
313 const T &operator*() const { return *get(); }
314 const T *operator->() const { return get(); }
315
Brian Silvermande9f3ff2020-04-28 16:56:58 -0700316 // Returns true if this fetcher is valid and connected to a channel.
Milind Upadhyay49174a72021-04-10 16:24:57 -0700317 bool valid() const { return static_cast<bool>(fetcher_); }
Brian Silvermande9f3ff2020-04-28 16:56:58 -0700318
Austin Schuhca75b6a2020-12-15 21:12:24 -0800319 // Copies the current flatbuffer into a FlatbufferVector.
320 FlatbufferVector<T> CopyFlatBuffer() const {
321 return context().template CopyFlatBuffer<T>();
322 }
323
Alex Perrycb7da4b2019-08-28 19:35:56 -0700324 private:
325 friend class EventLoop;
326 Fetcher(::std::unique_ptr<RawFetcher> fetcher)
327 : fetcher_(::std::move(fetcher)) {}
328 ::std::unique_ptr<RawFetcher> fetcher_;
329};
330
331// Sends messages to a channel.
332template <typename T>
333class Sender {
334 public:
335 Sender() {}
336
337 // Represents a single message about to be sent to the queue.
338 // The lifecycle goes:
339 //
340 // Builder builder = sender.MakeBuilder();
341 // T::Builder t_builder = builder.MakeBuilder<T>();
342 // Populate(&t_builder);
343 // builder.Send(t_builder.Finish());
344 class Builder {
345 public:
Austin Schuh1af273d2020-03-07 20:11:34 -0800346 Builder(RawSender *sender, ChannelPreallocatedAllocator *allocator)
Brian Silverman9dd793b2020-01-31 23:52:21 -0800347 : fbb_(allocator->size(), allocator),
348 allocator_(allocator),
349 sender_(sender) {
Brian Silvermana1652f32020-01-29 20:41:44 -0800350 CheckChannelDataAlignment(allocator->data(), allocator->size());
Austin Schuhd7b15da2020-02-17 15:06:11 -0800351 fbb_.ForceDefaults(true);
Alex Perrycb7da4b2019-08-28 19:35:56 -0700352 }
Brian Silvermana1652f32020-01-29 20:41:44 -0800353 Builder() {}
354 Builder(const Builder &) = delete;
355 Builder(Builder &&) = default;
356
357 Builder &operator=(const Builder &) = delete;
358 Builder &operator=(Builder &&) = default;
Alex Perrycb7da4b2019-08-28 19:35:56 -0700359
360 flatbuffers::FlatBufferBuilder *fbb() { return &fbb_; }
361
362 template <typename T2>
363 typename T2::Builder MakeBuilder() {
364 return typename T2::Builder(fbb_);
365 }
366
milind1f1dca32021-07-03 13:50:07 -0700367 RawSender::Error Send(flatbuffers::Offset<T> offset) {
Alex Perrycb7da4b2019-08-28 19:35:56 -0700368 fbb_.Finish(offset);
milind1f1dca32021-07-03 13:50:07 -0700369 const auto err = sender_->Send(fbb_.GetSize());
Brian Silverman9dd793b2020-01-31 23:52:21 -0800370 // Ensure fbb_ knows it shouldn't access the memory any more.
371 fbb_ = flatbuffers::FlatBufferBuilder();
milind1f1dca32021-07-03 13:50:07 -0700372 return err;
Alex Perrycb7da4b2019-08-28 19:35:56 -0700373 }
374
milind1f1dca32021-07-03 13:50:07 -0700375 // Equivalent to RawSender::CheckOk
376 void CheckOk(const RawSender::Error err) { sender_->CheckOk(err); };
377
Alex Perrycb7da4b2019-08-28 19:35:56 -0700378 // CHECKs that this message was sent.
Brian Silverman9dd793b2020-01-31 23:52:21 -0800379 void CheckSent() {
380 CHECK(!allocator_->is_allocated()) << ": Message was not sent yet";
381 }
Alex Perrycb7da4b2019-08-28 19:35:56 -0700382
Brian Silverman341b57e2020-06-23 16:23:18 -0700383 // Detaches a buffer, for later use calling Sender::Send directly.
384 //
385 // Note that the underlying memory remains with the Sender, so creating
386 // another Builder before destroying the FlatbufferDetachedBuffer will fail.
387 FlatbufferDetachedBuffer<T> Detach(flatbuffers::Offset<T> offset) {
388 fbb_.Finish(offset);
389 return fbb_.Release();
390 }
391
Alex Perrycb7da4b2019-08-28 19:35:56 -0700392 private:
Alex Perrycb7da4b2019-08-28 19:35:56 -0700393 flatbuffers::FlatBufferBuilder fbb_;
Austin Schuh1af273d2020-03-07 20:11:34 -0800394 ChannelPreallocatedAllocator *allocator_;
Alex Perrycb7da4b2019-08-28 19:35:56 -0700395 RawSender *sender_;
396 };
397
398 // Constructs an above builder.
Brian Silverman9dd793b2020-01-31 23:52:21 -0800399 //
400 // Only a single one of these may be "alive" for this object at any point in
401 // time. After calling Send on the result, it is no longer "alive". This means
402 // that you must manually reset a variable holding the return value (by
403 // assigning a default-constructed Builder to it) before calling this method
404 // again to overwrite the value in the variable.
Alex Perrycb7da4b2019-08-28 19:35:56 -0700405 Builder MakeBuilder();
406
Austin Schuha28cbc32019-12-27 16:28:04 -0800407 // Sends a prebuilt flatbuffer.
James Kuszmaulad523042022-10-05 16:47:33 -0700408 // This will copy the data out of the provided flatbuffer, and so does not
409 // have to correspond to an existing Builder.
milind1f1dca32021-07-03 13:50:07 -0700410 RawSender::Error Send(const NonSizePrefixedFlatbuffer<T> &flatbuffer);
Austin Schuha28cbc32019-12-27 16:28:04 -0800411
Brian Silverman341b57e2020-06-23 16:23:18 -0700412 // Sends a prebuilt flatbuffer which was detached from a Builder created via
413 // MakeBuilder() on this object.
milind1f1dca32021-07-03 13:50:07 -0700414 RawSender::Error SendDetached(FlatbufferDetachedBuffer<T> detached);
415
416 // Equivalent to RawSender::CheckOk
417 void CheckOk(const RawSender::Error err) { sender_->CheckOk(err); };
Brian Silverman341b57e2020-06-23 16:23:18 -0700418
Austin Schuh39788ff2019-12-01 18:22:57 -0800419 // Returns the name of the underlying queue.
Austin Schuh1e869472019-12-01 13:36:10 -0800420 const Channel *channel() const { return sender_->channel(); }
Alex Perrycb7da4b2019-08-28 19:35:56 -0700421
James Kuszmaulad523042022-10-05 16:47:33 -0700422 // Returns true if the Sender is a valid Sender. If you, e.g., are using
423 // TryMakeSender, then you must check valid() before attempting to use the
424 // Sender.
Austin Schuhe33c08d2022-02-03 18:15:21 -0800425 // TODO(austin): Deprecate the operator bool.
Austin Schuha0c41ba2020-09-10 22:59:14 -0700426 operator bool() const { return sender_ ? true : false; }
Austin Schuhe33c08d2022-02-03 18:15:21 -0800427 bool valid() const { return static_cast<bool>(sender_); }
Tyler Chatow67ddb032020-01-12 14:30:04 -0800428
Austin Schuh7bc59052020-02-16 23:48:33 -0800429 // Returns the time_points that the last message was sent at.
430 aos::monotonic_clock::time_point monotonic_sent_time() const {
431 return sender_->monotonic_sent_time();
432 }
433 aos::realtime_clock::time_point realtime_sent_time() const {
434 return sender_->realtime_sent_time();
435 }
436 // Returns the queue index that this was sent with.
437 uint32_t sent_queue_index() const { return sender_->sent_queue_index(); }
438
Brian Silverman4f4e0612020-08-12 19:54:41 -0700439 // Returns the buffer index which MakeBuilder() will expose access to. This is
440 // the buffer the caller can fill out.
441 int buffer_index() const { return sender_->buffer_index(); }
442
Alex Perrycb7da4b2019-08-28 19:35:56 -0700443 private:
444 friend class EventLoop;
445 Sender(std::unique_ptr<RawSender> sender) : sender_(std::move(sender)) {}
446 std::unique_ptr<RawSender> sender_;
447};
448
milind1f1dca32021-07-03 13:50:07 -0700449// Class for keeping a count of send failures on a certain channel
450class SendFailureCounter {
451 public:
452 inline void Count(const RawSender::Error err) {
453 failures_ += static_cast<size_t>(err != RawSender::Error::kOk);
454 just_failed_ = (err != RawSender::Error::kOk);
455 }
456
457 inline size_t failures() const { return failures_; }
458 inline bool just_failed() const { return just_failed_; }
459
460 private:
461 size_t failures_ = 0;
462 bool just_failed_ = false;
463};
464
Brian Silverman4f4e0612020-08-12 19:54:41 -0700465// Interface for timers.
Alex Perrycb7da4b2019-08-28 19:35:56 -0700466class TimerHandler {
467 public:
Austin Schuh39788ff2019-12-01 18:22:57 -0800468 virtual ~TimerHandler();
Alex Perrycb7da4b2019-08-28 19:35:56 -0700469
470 // Timer should sleep until base, base + offset, base + offset * 2, ...
471 // If repeat_offset isn't set, the timer only expires once.
James Kuszmaul8866e642022-06-10 16:00:36 -0700472 // base must be greater than or equal to zero.
Alex Perrycb7da4b2019-08-28 19:35:56 -0700473 virtual void Setup(monotonic_clock::time_point base,
474 monotonic_clock::duration repeat_offset =
475 ::aos::monotonic_clock::zero()) = 0;
476
477 // Stop future calls to callback().
478 virtual void Disable() = 0;
Austin Schuh1540c2f2019-11-29 21:59:29 -0800479
480 // Sets and gets the name of the timer. Set this if you want a descriptive
481 // name in the timing report.
482 void set_name(std::string_view name) { name_ = std::string(name); }
483 const std::string_view name() const { return name_; }
484
Austin Schuh39788ff2019-12-01 18:22:57 -0800485 protected:
486 TimerHandler(EventLoop *event_loop, std::function<void()> fn);
487
Austin Schuh9b1d6282022-06-10 17:03:21 -0700488 template <typename T>
489 monotonic_clock::time_point Call(T get_time,
490 monotonic_clock::time_point event_time);
Austin Schuh39788ff2019-12-01 18:22:57 -0800491
Austin Schuh1540c2f2019-11-29 21:59:29 -0800492 private:
Austin Schuh39788ff2019-12-01 18:22:57 -0800493 friend class EventLoop;
494
495 EventLoop *event_loop_;
496 // The function to call when Call is called.
497 std::function<void()> fn_;
Austin Schuh1540c2f2019-11-29 21:59:29 -0800498 std::string name_;
Austin Schuh39788ff2019-12-01 18:22:57 -0800499
500 internal::TimerTiming timing_;
Brian Silverman79ec7fc2020-06-08 20:11:22 -0500501 Ftrace ftrace_;
Alex Perrycb7da4b2019-08-28 19:35:56 -0700502};
503
504// Interface for phased loops. They are built on timers.
505class PhasedLoopHandler {
506 public:
Austin Schuh39788ff2019-12-01 18:22:57 -0800507 virtual ~PhasedLoopHandler();
Alex Perrycb7da4b2019-08-28 19:35:56 -0700508
509 // Sets the interval and offset. Any changes to interval and offset only take
510 // effect when the handler finishes running.
Austin Schuh39788ff2019-12-01 18:22:57 -0800511 void set_interval_and_offset(const monotonic_clock::duration interval,
512 const monotonic_clock::duration offset) {
513 phased_loop_.set_interval_and_offset(interval, offset);
514 }
Austin Schuh1540c2f2019-11-29 21:59:29 -0800515
516 // Sets and gets the name of the timer. Set this if you want a descriptive
517 // name in the timing report.
518 void set_name(std::string_view name) { name_ = std::string(name); }
519 const std::string_view name() const { return name_; }
520
Austin Schuh39788ff2019-12-01 18:22:57 -0800521 protected:
522 void Call(std::function<monotonic_clock::time_point()> get_time,
523 std::function<void(monotonic_clock::time_point)> schedule);
524
525 PhasedLoopHandler(EventLoop *event_loop, std::function<void(int)> fn,
526 const monotonic_clock::duration interval,
527 const monotonic_clock::duration offset);
528
Austin Schuh1540c2f2019-11-29 21:59:29 -0800529 private:
Austin Schuh39788ff2019-12-01 18:22:57 -0800530 friend class EventLoop;
531
532 void Reschedule(std::function<void(monotonic_clock::time_point)> schedule,
533 monotonic_clock::time_point monotonic_now) {
534 cycles_elapsed_ += phased_loop_.Iterate(monotonic_now);
535 schedule(phased_loop_.sleep_time());
536 }
537
538 virtual void Schedule(monotonic_clock::time_point sleep_time) = 0;
539
540 EventLoop *event_loop_;
541 std::function<void(int)> fn_;
Austin Schuh1540c2f2019-11-29 21:59:29 -0800542 std::string name_;
Austin Schuh39788ff2019-12-01 18:22:57 -0800543 time::PhasedLoop phased_loop_;
544
545 int cycles_elapsed_ = 0;
546
547 internal::TimerTiming timing_;
Brian Silverman79ec7fc2020-06-08 20:11:22 -0500548 Ftrace ftrace_;
Alex Perrycb7da4b2019-08-28 19:35:56 -0700549};
550
Austin Schuh3054f5f2021-07-21 15:38:01 -0700551// Note, it is supported to create only:
552// multiple fetchers, and (one sender or one watcher) per <name, type>
553// tuple.
Alex Perrycb7da4b2019-08-28 19:35:56 -0700554class EventLoop {
555 public:
Austin Schuh3054f5f2021-07-21 15:38:01 -0700556 // Holds configuration by reference for the lifetime of this object. It may
557 // never be mutated externally in any way.
Austin Schuh83c7f702021-01-19 22:36:29 -0800558 EventLoop(const Configuration *configuration);
Alex Perrycb7da4b2019-08-28 19:35:56 -0700559
Austin Schuh39788ff2019-12-01 18:22:57 -0800560 virtual ~EventLoop();
Alex Perrycb7da4b2019-08-28 19:35:56 -0700561
562 // Current time.
Stephan Pleines559fa6c2022-01-06 17:23:51 -0800563 virtual monotonic_clock::time_point monotonic_now() const = 0;
564 virtual realtime_clock::time_point realtime_now() const = 0;
Alex Perrycb7da4b2019-08-28 19:35:56 -0700565
Brian Silvermande9f3ff2020-04-28 16:56:58 -0700566 template <typename T>
Austin Schuha0654152021-02-21 21:38:24 -0800567 const Channel *GetChannel(const std::string_view channel_name) {
Austin Schuhcaa2a5d2020-11-01 22:38:20 -0800568 return configuration::GetChannel(configuration(), channel_name,
Austin Schuh0de30f32020-12-06 12:44:28 -0800569 T::GetFullyQualifiedName(), name(), node(),
Austin Schuha0654152021-02-21 21:38:24 -0800570 true);
571 }
milind1f1dca32021-07-03 13:50:07 -0700572 // Returns true if the channel exists in the configuration.
Austin Schuha0654152021-02-21 21:38:24 -0800573 template <typename T>
574 bool HasChannel(const std::string_view channel_name) {
575 return GetChannel<T>(channel_name) != nullptr;
Brian Silvermande9f3ff2020-04-28 16:56:58 -0700576 }
577
Brian Silverman631b6262021-11-10 12:25:08 -0800578 // Like MakeFetcher, but returns an invalid fetcher if the given channel is
579 // not readable on this node or does not exist.
580 template <typename T>
581 Fetcher<T> TryMakeFetcher(const std::string_view channel_name) {
582 const Channel *const channel = GetChannel<T>(channel_name);
583 if (channel == nullptr) {
584 return Fetcher<T>();
585 }
586
587 if (!configuration::ChannelIsReadableOnNode(channel, node())) {
588 return Fetcher<T>();
589 }
590
591 return Fetcher<T>(MakeRawFetcher(channel));
592 }
593
Alex Perrycb7da4b2019-08-28 19:35:56 -0700594 // Makes a class that will always fetch the most recent value
595 // sent to the provided channel.
596 template <typename T>
James Kuszmaul3ae42262019-11-08 12:33:41 -0800597 Fetcher<T> MakeFetcher(const std::string_view channel_name) {
Brian Silverman631b6262021-11-10 12:25:08 -0800598 CHECK(HasChannel<T>(channel_name))
Alex Perrycb7da4b2019-08-28 19:35:56 -0700599 << ": Channel { \"name\": \"" << channel_name << "\", \"type\": \""
600 << T::GetFullyQualifiedName() << "\" } not found in config.";
601
Brian Silverman631b6262021-11-10 12:25:08 -0800602 Fetcher<T> result = TryMakeFetcher<T>(channel_name);
603 if (!result.valid()) {
Austin Schuhca4828c2019-12-28 14:21:35 -0800604 LOG(FATAL) << "Channel { \"name\": \"" << channel_name
605 << "\", \"type\": \"" << T::GetFullyQualifiedName()
606 << "\" } is not able to be fetched on this node. Check your "
607 "configuration.";
Austin Schuh217a9782019-12-21 23:02:50 -0800608 }
609
Brian Silverman631b6262021-11-10 12:25:08 -0800610 return result;
611 }
612
613 // Like MakeSender, but returns an invalid sender if the given channel is
James Kuszmaulb8887592021-12-09 14:54:50 -0800614 // not sendable on this node or does not exist.
Brian Silverman631b6262021-11-10 12:25:08 -0800615 template <typename T>
616 Sender<T> TryMakeSender(const std::string_view channel_name) {
617 const Channel *channel = GetChannel<T>(channel_name);
618 if (channel == nullptr) {
619 return Sender<T>();
620 }
621
622 if (!configuration::ChannelIsSendableOnNode(channel, node())) {
623 return Sender<T>();
624 }
625
626 return Sender<T>(MakeRawSender(channel));
Alex Perrycb7da4b2019-08-28 19:35:56 -0700627 }
628
629 // Makes class that allows constructing and sending messages to
630 // the provided channel.
631 template <typename T>
James Kuszmaul3ae42262019-11-08 12:33:41 -0800632 Sender<T> MakeSender(const std::string_view channel_name) {
Brian Silverman631b6262021-11-10 12:25:08 -0800633 CHECK(HasChannel<T>(channel_name))
Alex Perrycb7da4b2019-08-28 19:35:56 -0700634 << ": Channel { \"name\": \"" << channel_name << "\", \"type\": \""
Austin Schuh28fedcb2020-02-08 15:59:58 -0800635 << T::GetFullyQualifiedName() << "\" } not found in config for "
Austin Schuh2f8fd752020-09-01 22:38:28 -0700636 << name()
Austin Schuhcaa2a5d2020-11-01 22:38:20 -0800637 << (configuration::MultiNode(configuration())
Austin Schuh2f8fd752020-09-01 22:38:28 -0700638 ? absl::StrCat(" on node ", node()->name()->string_view())
639 : ".");
Alex Perrycb7da4b2019-08-28 19:35:56 -0700640
Brian Silverman631b6262021-11-10 12:25:08 -0800641 Sender<T> result = TryMakeSender<T>(channel_name);
642 if (!result) {
Austin Schuhca4828c2019-12-28 14:21:35 -0800643 LOG(FATAL) << "Channel { \"name\": \"" << channel_name
644 << "\", \"type\": \"" << T::GetFullyQualifiedName()
645 << "\" } is not able to be sent on this node. Check your "
646 "configuration.";
Austin Schuh217a9782019-12-21 23:02:50 -0800647 }
648
Brian Silverman631b6262021-11-10 12:25:08 -0800649 return result;
Alex Perrycb7da4b2019-08-28 19:35:56 -0700650 }
651
652 // This will watch messages sent to the provided channel.
653 //
Brian Silverman454bc112020-03-05 14:21:25 -0800654 // w must have a non-polymorphic operator() (aka it can only be called with a
655 // single set of arguments; no overloading or templates). It must be callable
656 // with this signature:
657 // void(const MessageType &);
Alex Perrycb7da4b2019-08-28 19:35:56 -0700658 //
Brian Silverman454bc112020-03-05 14:21:25 -0800659 // Lambdas are a common form for w. A std::function will work too.
660 //
661 // Note that bind expressions have polymorphic call operators, so they are not
662 // allowed.
663 //
664 // We template Watch as a whole instead of using std::function<void(const T
665 // &)> to allow deducing MessageType from lambdas and other things which are
666 // implicitly convertible to std::function, but not actually std::function
667 // instantiations. Template deduction guides might allow solving this
668 // differently in newer versions of C++, but those have their own corner
669 // cases.
Alex Perrycb7da4b2019-08-28 19:35:56 -0700670 template <typename Watch>
Brian Silverman454bc112020-03-05 14:21:25 -0800671 void MakeWatcher(const std::string_view channel_name, Watch &&w);
672
673 // Like MakeWatcher, but doesn't have access to the message data. This may be
674 // implemented to use less resources than an equivalent MakeWatcher.
675 //
Brian Silverman6b8a3c32020-03-06 11:26:14 -0800676 // The function will still have access to context(), although that will have
677 // its data field set to nullptr.
Brian Silverman454bc112020-03-05 14:21:25 -0800678 template <typename MessageType>
679 void MakeNoArgWatcher(const std::string_view channel_name,
680 std::function<void()> w);
Alex Perrycb7da4b2019-08-28 19:35:56 -0700681
682 // The passed in function will be called when the event loop starts.
683 // Use this to run code once the thread goes into "real-time-mode",
684 virtual void OnRun(::std::function<void()> on_run) = 0;
685
Austin Schuh217a9782019-12-21 23:02:50 -0800686 // Gets the name of the event loop. This is the application name.
James Kuszmaul3ae42262019-11-08 12:33:41 -0800687 virtual const std::string_view name() const = 0;
Alex Perrycb7da4b2019-08-28 19:35:56 -0700688
Austin Schuh217a9782019-12-21 23:02:50 -0800689 // Returns the node that this event loop is running on. Returns nullptr if we
690 // are running in single-node mode.
691 virtual const Node *node() const = 0;
692
Alex Perrycb7da4b2019-08-28 19:35:56 -0700693 // Creates a timer that executes callback when the timer expires
694 // Returns a TimerHandle for configuration of the timer
milind-u61227f22021-08-29 15:58:33 -0700695 // TODO(milind): callback should take the number of cycles elapsed as a
696 // parameter.
Alex Perrycb7da4b2019-08-28 19:35:56 -0700697 virtual TimerHandler *AddTimer(::std::function<void()> callback) = 0;
698
699 // Creates a timer that executes callback periodically at the specified
700 // interval and offset. Returns a PhasedLoopHandler for interacting with the
701 // timer.
702 virtual PhasedLoopHandler *AddPhasedLoop(
703 ::std::function<void(int)> callback,
704 const monotonic_clock::duration interval,
705 const monotonic_clock::duration offset = ::std::chrono::seconds(0)) = 0;
706
Austin Schuh217a9782019-12-21 23:02:50 -0800707 // TODO(austin): OnExit for cleanup.
Alex Perrycb7da4b2019-08-28 19:35:56 -0700708
Austin Schuh3054f5f2021-07-21 15:38:01 -0700709 // May be safely called from any thread.
Alex Perrycb7da4b2019-08-28 19:35:56 -0700710 bool is_running() const { return is_running_.load(); }
711
712 // Sets the scheduler priority to run the event loop at. This may not be
713 // called after we go into "real-time-mode".
714 virtual void SetRuntimeRealtimePriority(int priority) = 0;
Austin Schuh65493d62022-08-17 15:10:37 -0700715 // Defaults to 0 if this loop will not run realtime.
716 virtual int runtime_realtime_priority() const = 0;
717
718 static cpu_set_t DefaultAffinity() {
719 cpu_set_t result;
720 for (int i = 0; i < CPU_SETSIZE; ++i) {
721 CPU_SET(i, &result);
722 }
723 return result;
724 }
Alex Perrycb7da4b2019-08-28 19:35:56 -0700725
Brian Silverman6a54ff32020-04-28 16:41:39 -0700726 // Sets the scheduler affinity to run the event loop with. This may only be
727 // called before Run().
728 virtual void SetRuntimeAffinity(const cpu_set_t &cpuset) = 0;
Austin Schuh65493d62022-08-17 15:10:37 -0700729 // Defaults to DefaultAffinity() if this loop will not run pinned.
730 virtual const cpu_set_t &runtime_affinity() const = 0;
Brian Silverman6a54ff32020-04-28 16:41:39 -0700731
Austin Schuh217a9782019-12-21 23:02:50 -0800732 // Fetches new messages from the provided channel (path, type).
733 //
734 // Note: this channel must be a member of the exact configuration object this
735 // was built with.
Alex Perrycb7da4b2019-08-28 19:35:56 -0700736 virtual std::unique_ptr<RawFetcher> MakeRawFetcher(
737 const Channel *channel) = 0;
738
Austin Schuh217a9782019-12-21 23:02:50 -0800739 // Watches channel (name, type) for new messages.
Alex Perrycb7da4b2019-08-28 19:35:56 -0700740 virtual void MakeRawWatcher(
741 const Channel *channel,
742 std::function<void(const Context &context, const void *message)>
743 watcher) = 0;
744
Brian Silverman454bc112020-03-05 14:21:25 -0800745 // Watches channel (name, type) for new messages, without needing to extract
746 // the message contents. Default implementation simply re-uses MakeRawWatcher.
747 virtual void MakeRawNoArgWatcher(
748 const Channel *channel,
749 std::function<void(const Context &context)> watcher) {
750 MakeRawWatcher(channel, [watcher](const Context &context, const void *) {
Brian Silverman6b8a3c32020-03-06 11:26:14 -0800751 Context new_context = context;
752 new_context.data = nullptr;
Brian Silverman4f4e0612020-08-12 19:54:41 -0700753 new_context.buffer_index = -1;
Brian Silverman6b8a3c32020-03-06 11:26:14 -0800754 watcher(new_context);
Brian Silverman454bc112020-03-05 14:21:25 -0800755 });
756 }
757
Austin Schuh217a9782019-12-21 23:02:50 -0800758 // Creates a raw sender for the provided channel. This is used for reflection
759 // based sending.
760 // Note: this ignores any node constraints. Ignore at your own peril.
761 virtual std::unique_ptr<RawSender> MakeRawSender(const Channel *channel) = 0;
762
Austin Schuh6231cc32019-12-07 13:06:15 -0800763 // Returns the context for the current callback.
Alex Perrycb7da4b2019-08-28 19:35:56 -0700764 const Context &context() const { return context_; }
765
766 // Returns the configuration that this event loop was built with.
767 const Configuration *configuration() const { return configuration_; }
768
Austin Schuh39788ff2019-12-01 18:22:57 -0800769 // Prevents the event loop from sending a timing report.
Brian Silvermanbf889922021-11-10 12:41:57 -0800770 void SkipTimingReport();
Austin Schuh39788ff2019-12-01 18:22:57 -0800771
Brian Silverman4f4e0612020-08-12 19:54:41 -0700772 // Prevents AOS_LOG being sent to message on /aos.
Tyler Chatow67ddb032020-01-12 14:30:04 -0800773 void SkipAosLog() { skip_logger_ = true; }
774
Brian Silverman4f4e0612020-08-12 19:54:41 -0700775 // Returns the number of buffers for this channel. This corresponds with the
776 // range of Context::buffer_index values for this channel.
777 virtual int NumberBuffers(const Channel *channel) = 0;
778
Austin Schuh20ac95d2020-12-05 17:24:19 -0800779 // Returns the boot UUID.
Austin Schuh83c7f702021-01-19 22:36:29 -0800780 virtual const UUID &boot_uuid() const = 0;
Austin Schuh20ac95d2020-12-05 17:24:19 -0800781
Alex Perrycb7da4b2019-08-28 19:35:56 -0700782 protected:
Austin Schuh217a9782019-12-21 23:02:50 -0800783 // Sets the name of the event loop. This is the application name.
784 virtual void set_name(const std::string_view name) = 0;
785
Alex Perrycb7da4b2019-08-28 19:35:56 -0700786 void set_is_running(bool value) { is_running_.store(value); }
787
Austin Schuh39788ff2019-12-01 18:22:57 -0800788 // Validates that channel exists inside configuration_ and finds its index.
789 int ChannelIndex(const Channel *channel);
Alex Perrycb7da4b2019-08-28 19:35:56 -0700790
Brian Silverman5120afb2020-01-31 17:44:35 -0800791 // Returns the state for the watcher on the corresponding channel. This
792 // watcher must exist before calling this.
793 WatcherState *GetWatcherState(const Channel *channel);
794
Brian Silverman6d2b3592020-06-18 14:40:15 -0700795 // Returns a Sender's protected RawSender.
Brian Silverman5120afb2020-01-31 17:44:35 -0800796 template <typename T>
797 static RawSender *GetRawSender(aos::Sender<T> *sender) {
798 return sender->sender_.get();
799 }
800
Brian Silverman6d2b3592020-06-18 14:40:15 -0700801 // Returns a Fetcher's protected RawFetcher.
802 template <typename T>
803 static RawFetcher *GetRawFetcher(aos::Fetcher<T> *fetcher) {
804 return fetcher->fetcher_.get();
805 }
806
Austin Schuh6231cc32019-12-07 13:06:15 -0800807 // Context available for watchers, timers, and phased loops.
Alex Perrycb7da4b2019-08-28 19:35:56 -0700808 Context context_;
809
Austin Schuh39788ff2019-12-01 18:22:57 -0800810 friend class RawSender;
811 friend class TimerHandler;
812 friend class RawFetcher;
813 friend class PhasedLoopHandler;
814 friend class WatcherState;
815
816 // Methods used to implement timing reports.
817 void NewSender(RawSender *sender);
818 void DeleteSender(RawSender *sender);
819 TimerHandler *NewTimer(std::unique_ptr<TimerHandler> timer);
820 PhasedLoopHandler *NewPhasedLoop(
821 std::unique_ptr<PhasedLoopHandler> phased_loop);
822 void NewFetcher(RawFetcher *fetcher);
823 void DeleteFetcher(RawFetcher *fetcher);
824 WatcherState *NewWatcher(std::unique_ptr<WatcherState> watcher);
825
Brian Silverman0fc69932020-01-24 21:54:02 -0800826 // Tracks that we have a (single) watcher on the given channel.
827 void TakeWatcher(const Channel *channel);
828 // Tracks that we have at least one sender on the given channel.
829 void TakeSender(const Channel *channel);
830
Austin Schuh39788ff2019-12-01 18:22:57 -0800831 std::vector<RawSender *> senders_;
Austin Schuh7d87b672019-12-01 20:23:49 -0800832 std::vector<RawFetcher *> fetchers_;
833
Austin Schuh39788ff2019-12-01 18:22:57 -0800834 std::vector<std::unique_ptr<TimerHandler>> timers_;
835 std::vector<std::unique_ptr<PhasedLoopHandler>> phased_loops_;
Austin Schuh39788ff2019-12-01 18:22:57 -0800836 std::vector<std::unique_ptr<WatcherState>> watchers_;
837
Brian Silvermance418d02021-11-03 11:25:52 -0700838 // Does nothing if timing reports are disabled.
Austin Schuh39788ff2019-12-01 18:22:57 -0800839 void SendTimingReport();
Brian Silvermance418d02021-11-03 11:25:52 -0700840
Austin Schuh39788ff2019-12-01 18:22:57 -0800841 void UpdateTimingReport();
842 void MaybeScheduleTimingReports();
843
844 std::unique_ptr<RawSender> timing_report_sender_;
845
Austin Schuh7d87b672019-12-01 20:23:49 -0800846 // Tracks which event sources (timers and watchers) have data, and which
847 // don't. Added events may not change their event_time().
848 // TODO(austin): Test case 1: timer triggers at t1, handler takes until after
849 // t2 to run, t2 should then be picked up without a context switch.
850 void AddEvent(EventLoopEvent *event);
851 void RemoveEvent(EventLoopEvent *event);
852 size_t EventCount() const { return events_.size(); }
853 EventLoopEvent *PopEvent();
854 EventLoopEvent *PeekEvent() { return events_.front(); }
855 void ReserveEvents();
856
857 std::vector<EventLoopEvent *> events_;
Brian Silvermanbd405c02020-06-23 16:25:23 -0700858 size_t event_generation_ = 1;
Austin Schuh7d87b672019-12-01 20:23:49 -0800859
Tyler Chatow67ddb032020-01-12 14:30:04 -0800860 // If true, don't send AOS_LOG to /aos
861 bool skip_logger_ = false;
862
Austin Schuha9012be2021-07-21 15:19:11 -0700863 // Sets context_ for a timed event which is supposed to happen at the provided
864 // time.
865 void SetTimerContext(monotonic_clock::time_point monotonic_event_time);
Austin Schuh0debde12022-08-17 16:25:17 -0700866 // Clears context_ so it only has invalid times and elements in it.
867 void ClearContext();
Austin Schuha9012be2021-07-21 15:19:11 -0700868
Austin Schuhde8a8ff2019-11-30 15:25:36 -0800869 private:
Austin Schuh39788ff2019-12-01 18:22:57 -0800870 virtual pid_t GetTid() = 0;
871
872 FlatbufferDetachedBuffer<timing::Report> timing_report_;
873
Austin Schuhde8a8ff2019-11-30 15:25:36 -0800874 ::std::atomic<bool> is_running_{false};
875
Alex Perrycb7da4b2019-08-28 19:35:56 -0700876 const Configuration *configuration_;
Austin Schuh39788ff2019-12-01 18:22:57 -0800877
878 // If true, don't send out timing reports.
879 bool skip_timing_report_ = false;
Brian Silverman0fc69932020-01-24 21:54:02 -0800880
milind1f1dca32021-07-03 13:50:07 -0700881 SendFailureCounter timing_report_failure_counter_;
882
Brian Silverman0fc69932020-01-24 21:54:02 -0800883 absl::btree_set<const Channel *> taken_watchers_, taken_senders_;
Alex Perrycb7da4b2019-08-28 19:35:56 -0700884};
885
Brian Silvermane1fe2512022-08-14 23:18:50 -0700886// Interface for terminating execution of an EventLoop.
887//
888// Prefer this over binding a lambda to an Exit() method when passing ownership
889// in complicated ways because implementations should have assertions to catch
890// it outliving the object it's referring to, instead of having a
891// use-after-free.
892//
893// This is not exposed by EventLoop directly because different EventLoop
894// implementations provide this functionality at different scopes, or possibly
895// not at all.
896class ExitHandle {
897 public:
898 ExitHandle() = default;
899 virtual ~ExitHandle() = default;
900
901 // Exits some set of event loops. Details depend on the implementation.
902 //
903 // This means no more events will be processed, but any currently being
904 // processed will finish.
905 virtual void Exit() = 0;
906};
907
Alex Perrycb7da4b2019-08-28 19:35:56 -0700908} // namespace aos
909
Austin Schuhb8075812020-10-19 09:36:49 -0700910#include "aos/events/event_loop_tmpl.h" // IWYU pragma: export
Alex Perrycb7da4b2019-08-28 19:35:56 -0700911
912#endif // AOS_EVENTS_EVENT_LOOP_H