| // Copyright 2022 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #ifndef QUICHE_QUIC_CORE_IO_QUIC_POLL_EVENT_LOOP_H_ |
| #define QUICHE_QUIC_CORE_IO_QUIC_POLL_EVENT_LOOP_H_ |
| |
| #if defined(_WIN32) |
| #include <winsock2.h> |
| #else |
| #include <poll.h> |
| #endif |
| |
| #include <memory> |
| |
| #include "absl/container/btree_map.h" |
| #include "absl/types/span.h" |
| #include "quiche/quic/core/io/quic_event_loop.h" |
| #include "quiche/quic/core/io/socket.h" |
| #include "quiche/quic/core/quic_alarm.h" |
| #include "quiche/quic/core/quic_alarm_factory.h" |
| #include "quiche/quic/core/quic_clock.h" |
| #include "quiche/common/quiche_linked_hash_map.h" |
| |
| namespace quic { |
| |
| // A simple and portable implementation of QuicEventLoop using poll(2). Works |
| // on all POSIX platforms (and can be potentially made to support Windows using |
| // WSAPoll). |
| // |
| // For most operations, this implementation has a typical runtime of |
| // O(N + log M), where N is the number of file descriptors, and M is the number |
| // of pending alarms. |
| // |
| // This API has to deal with the situations where callbacks are modified from |
| // the callbacks themselves. To address this, we use the following two |
| // approaches: |
| // 1. The code does not execute any callbacks until the very end of the |
| // processing, when all of the state for the event loop is consistent. |
| // 2. The callbacks are stored as weak pointers, since other callbacks can |
| // cause them to be unregistered. |
| class QuicPollEventLoop : public QuicEventLoop { |
| public: |
| QuicPollEventLoop(QuicClock* clock); |
| |
| // QuicEventLoop implementation. |
| bool SupportsEdgeTriggered() const override { return false; } |
| ABSL_MUST_USE_RESULT bool RegisterSocket( |
| SocketFd fd, QuicSocketEventMask events, |
| QuicSocketEventListener* listener) override; |
| ABSL_MUST_USE_RESULT bool UnregisterSocket(SocketFd fd) override; |
| ABSL_MUST_USE_RESULT bool RearmSocket(SocketFd fd, |
| QuicSocketEventMask events) override; |
| ABSL_MUST_USE_RESULT bool ArtificiallyNotifyEvent( |
| SocketFd fd, QuicSocketEventMask events) override; |
| void RunEventLoopOnce(QuicTime::Delta default_timeout) override; |
| std::unique_ptr<QuicAlarmFactory> CreateAlarmFactory() override; |
| const QuicClock* GetClock() override { return clock_; } |
| |
| protected: |
| // Allows poll(2) calls to be mocked out in unit tests. |
| virtual int PollSyscall(pollfd* fds, size_t nfds, int timeout); |
| |
| private: |
| friend class QuicPollEventLoopPeer; |
| |
| struct Registration { |
| QuicSocketEventMask events = 0; |
| QuicSocketEventListener* listener; |
| |
| QuicSocketEventMask artificially_notify_at_next_iteration = 0; |
| }; |
| |
| class Alarm : public QuicAlarm { |
| public: |
| Alarm(QuicPollEventLoop* loop, |
| QuicArenaScopedPtr<QuicAlarm::Delegate> delegate); |
| |
| void SetImpl() override; |
| void CancelImpl() override; |
| |
| void DoFire() { |
| current_schedule_handle_.reset(); |
| Fire(); |
| } |
| |
| private: |
| QuicPollEventLoop* loop_; |
| // Deleted when the alarm is cancelled, causing the corresponding weak_ptr |
| // in the alarm list to not be executed. |
| std::shared_ptr<Alarm*> current_schedule_handle_; |
| }; |
| |
| class AlarmFactory : public QuicAlarmFactory { |
| public: |
| AlarmFactory(QuicPollEventLoop* loop) : loop_(loop) {} |
| |
| // QuicAlarmFactory implementation. |
| QuicAlarm* CreateAlarm(QuicAlarm::Delegate* delegate) override; |
| QuicArenaScopedPtr<QuicAlarm> CreateAlarm( |
| QuicArenaScopedPtr<QuicAlarm::Delegate> delegate, |
| QuicConnectionArena* arena) override; |
| |
| private: |
| QuicPollEventLoop* loop_; |
| }; |
| |
| // Used for deferred execution of I/O callbacks. |
| struct ReadyListEntry { |
| SocketFd fd; |
| std::weak_ptr<Registration> registration; |
| QuicSocketEventMask events; |
| }; |
| |
| // We're using a linked hash map here to ensure the events are called in the |
| // registration order. This isn't strictly speaking necessary, but makes |
| // testing things easier. |
| using RegistrationMap = |
| quiche::QuicheLinkedHashMap<SocketFd, std::shared_ptr<Registration>>; |
| // Alarms are stored as weak pointers, since the alarm can be cancelled and |
| // disappear while in the queue. |
| using AlarmList = absl::btree_multimap<QuicTime, std::weak_ptr<Alarm*>>; |
| |
| // Returns the timeout for the next poll(2) call. It is typically the time at |
| // which the next alarm is supposed to activate. |
| QuicTime::Delta ComputePollTimeout(QuicTime now, |
| QuicTime::Delta default_timeout) const; |
| // Calls poll(2) with the provided timeout and dispatches the callbacks |
| // accordingly. |
| void ProcessIoEvents(QuicTime start_time, QuicTime::Delta timeout); |
| // Calls all of the alarm callbacks that are scheduled before or at |time|. |
| void ProcessAlarmsUpTo(QuicTime time); |
| |
| // Adds the I/O callbacks for |fd| to the |ready_lits| as appopriate. |
| void DispatchIoEvent(std::vector<ReadyListEntry>& ready_list, SocketFd fd, |
| short mask); // NOLINT(runtime/int) |
| // Runs all of the callbacks on the ready list. |
| void RunReadyCallbacks(std::vector<ReadyListEntry>& ready_list); |
| |
| // Calls poll() while handling EINTR. Returns the return value of poll(2) |
| // system call. |
| int PollWithRetries(absl::Span<pollfd> fds, QuicTime start_time, |
| QuicTime::Delta timeout); |
| |
| const QuicClock* clock_; |
| RegistrationMap registrations_; |
| AlarmList alarms_; |
| bool has_artificial_events_pending_ = false; |
| }; |
| |
| class QuicPollEventLoopFactory : public QuicEventLoopFactory { |
| public: |
| static QuicPollEventLoopFactory* Get() { |
| static QuicPollEventLoopFactory* factory = new QuicPollEventLoopFactory(); |
| return factory; |
| } |
| |
| std::unique_ptr<QuicEventLoop> Create(QuicClock* clock) override { |
| return std::make_unique<QuicPollEventLoop>(clock); |
| } |
| |
| std::string GetName() const override { return "poll(2)"; } |
| }; |
| |
| } // namespace quic |
| |
| #endif // QUICHE_QUIC_CORE_IO_QUIC_POLL_EVENT_LOOP_H_ |