blob: db295989c7189b6a5d54b28d042f32ae46ff2c1f [file] [log] [blame] [edit]
// 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_