From a69d6a0a35dac43f07d6304c5e58899b4555e777 Mon Sep 17 00:00:00 2001 From: yhirose Date: Fri, 20 Nov 2026 20:57:31 -0500 Subject: [PATCH] Add a one-shot Poller and create_socket_pair() Groundwork for an opt-in reactor that parks idle keep-alive connections instead of blocking a worker thread on each of them. detail::Poller delivers readiness once per arm(), so a descriptor is either armed (owned by the poller) or owned by whoever got the event. The same contract maps onto poll(), epoll, kqueue and Windows' AFD_POLL, so a backend can be added without touching its users. wake() ends a wait() from any thread; an armed descriptor must be disarmed before it is closed, which the poll() backend asserts. detail::PollPoller is the portable backend (poll() / WSAPoll()), and detail::create_socket_pair() emulates socketpair() on Windows with sockets that child processes do not inherit. Nothing uses them yet. --- httplib.h | 217 +++++++++++++++++++++++++++++++++++++++++++++++++++ test/test.cc | 198 ++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 415 insertions(+) diff --git a/httplib.h b/httplib.h index 845366e3..06a831fc 100644 --- a/httplib.h +++ b/httplib.h @@ -3930,6 +3930,62 @@ EncodingType encoding_type(const Request &req, const Response &res, EncodingType encoding_type(const Request &req, const Response &res); +// Creates a connected pair of stream sockets that child processes do not +// inherit. Windows has no socketpair(), so it is emulated there. +bool create_socket_pair(socket_t sv[2]); + +// One-shot readiness notification for a reactor: +// - A delivered event disarms the descriptor; arm() it again to wait again. +// - A hang-up or an error counts as readable. +// - Only an unarmed descriptor may be armed, and an armed one must be +// disarmed before it is closed. +// - wake() may be called from any thread; the rest belongs to one thread. +class Poller { +public: + using Token = uintptr_t; + + virtual ~Poller() = default; + + virtual bool arm(socket_t fd, Token token) = 0; + virtual void disarm(socket_t fd) = 0; + + // Fills `ready` in no particular order and returns whether wake() was + // called. A negative timeout waits until either happens. + virtual bool wait(int timeout_ms, std::vector &ready) = 0; + + virtual void wake() noexcept = 0; +}; + +// poll() on POSIX, WSAPoll() on Windows. Works everywhere. +class PollPoller final : public Poller { +public: + // nullptr when the wake sockets cannot be created. + static std::unique_ptr create(); + ~PollPoller() override; + + bool arm(socket_t fd, Token token) override; + void disarm(socket_t fd) override; + bool wait(int timeout_ms, std::vector &ready) override; + void wake() noexcept override; + +private: + PollPoller() = default; + void remove_at(size_t index); + + socket_t wake_read_ = INVALID_SOCKET; + socket_t wake_write_ = INVALID_SOCKET; + std::atomic wake_pending_{false}; + + // fds_[0] is wake_read_, which is always armed; tokens_[i] belongs to + // fds_[i]. + std::vector fds_; + std::vector tokens_; + std::unordered_map index_; +}; + +// The best poller for this platform, or nullptr when it cannot be created. +std::unique_ptr make_poller(); + class BufferStream final : public Stream { public: BufferStream() = default; @@ -7770,6 +7826,167 @@ inline bool is_accept_transient_error() { #endif } +inline bool create_socket_pair(socket_t sv[2]) { +#ifdef _WIN32 + auto listener = create_socket( + std::string(), "127.0.0.1", 0, AF_INET, 0, false, false, nullptr, + [](socket_t sock, struct addrinfo &ai, bool &) { + return ::bind(sock, ai.ai_addr, static_cast(ai.ai_addrlen)) == 0 && + ::listen(sock, 1) == 0; + }); + if (listener == INVALID_SOCKET) { return false; } + + socket_t a = INVALID_SOCKET; + socket_t b = INVALID_SOCKET; + sockaddr_in addr{}; + auto addr_len = static_cast(sizeof(addr)); + if (::getsockname(listener, reinterpret_cast(&addr), &addr_len) == + 0) { + a = create_socket(std::string(), "127.0.0.1", ntohs(addr.sin_port), AF_INET, + 0, true, false, nullptr, + [](socket_t sock, struct addrinfo &ai, bool &) { + return ::connect(sock, ai.ai_addr, + static_cast(ai.ai_addrlen)) == 0; + }); + // Unlike accept(), this keeps the listener's no-inherit flag. + if (a != INVALID_SOCKET) { + b = WSAAccept(listener, nullptr, nullptr, nullptr, 0); + } + } + close_socket(listener); + + // Any local process could connect while the listener was open, so make sure + // that the connection we accepted is the one we made. + if (b != INVALID_SOCKET) { + sockaddr_in local{}, peer{}; + auto local_len = static_cast(sizeof(local)); + auto peer_len = static_cast(sizeof(peer)); + if (::getsockname(a, reinterpret_cast(&local), &local_len) != + 0 || + ::getpeername(b, reinterpret_cast(&peer), &peer_len) != 0 || + local.sin_port != peer.sin_port || + local.sin_addr.s_addr != peer.sin_addr.s_addr) { + close_socket(b); + b = INVALID_SOCKET; + } + } + + if (b == INVALID_SOCKET) { + if (a != INVALID_SOCKET) { close_socket(a); } + return false; + } + sv[0] = a; + sv[1] = b; + return true; +#else +#ifdef SOCK_CLOEXEC + return ::socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, sv) == 0; +#else + if (::socketpair(AF_UNIX, SOCK_STREAM, 0, sv) != 0) { return false; } + fcntl(sv[0], F_SETFD, FD_CLOEXEC); + fcntl(sv[1], F_SETFD, FD_CLOEXEC); + return true; +#endif +#endif +} + +inline std::unique_ptr PollPoller::create() { + socket_t sv[2]; + if (!create_socket_pair(sv)) { return nullptr; } + + std::unique_ptr poller(new PollPoller()); + poller->wake_read_ = sv[0]; + poller->wake_write_ = sv[1]; + // wake() must not block its caller, and wait() must not block on a drain. + set_nonblocking(sv[0], true); + set_nonblocking(sv[1], true); + + struct pollfd pfd; + pfd.fd = sv[0]; + pfd.events = POLLIN; + pfd.revents = 0; + poller->fds_.push_back(pfd); + poller->tokens_.push_back(0); + return std::unique_ptr(poller.release()); +} + +inline PollPoller::~PollPoller() { + if (wake_write_ != INVALID_SOCKET) { close_socket(wake_write_); } + if (wake_read_ != INVALID_SOCKET) { close_socket(wake_read_); } +} + +inline bool PollPoller::arm(socket_t fd, Token token) { + assert(index_.find(fd) == index_.end()); + + struct pollfd pfd; + pfd.fd = fd; + pfd.events = POLLIN; + pfd.revents = 0; + index_[fd] = fds_.size(); + fds_.push_back(pfd); + tokens_.push_back(token); + return true; +} + +inline void PollPoller::disarm(socket_t fd) { + auto it = index_.find(fd); + if (it != index_.end()) { remove_at(it->second); } +} + +// Fills the hole with the last entry, so that arm() and disarm() are O(1). +inline void PollPoller::remove_at(size_t index) { + assert(index > 0 && index < fds_.size()); + auto last = fds_.size() - 1; + index_.erase(fds_[index].fd); + if (index != last) { + fds_[index] = fds_[last]; + tokens_[index] = tokens_[last]; + index_[fds_[index].fd] = index; + } + fds_.pop_back(); + tokens_.pop_back(); +} + +inline bool PollPoller::wait(int timeout_ms, std::vector &ready) { + ready.clear(); + + auto n = handle_EINTR([&]() { + return poll_wrapper(fds_.data(), static_cast(fds_.size()), + timeout_ms); + }); + if (n <= 0) { return false; } + + auto woken = fds_[0].revents != 0; + if (woken) { + n--; + // Clear the flag first: a wake() from here on sends another byte. + wake_pending_ = false; + char buf[64]; + read_socket(wake_read_, buf, sizeof(buf), CPPHTTPLIB_RECV_FLAGS); + } + + // Walk backwards: remove_at() moves the last entry, already seen, into the + // freed slot. + for (auto i = fds_.size(); n > 0 && i-- > 1;) { + auto revents = fds_[i].revents; + if (revents == 0) { continue; } + n--; + assert(!(revents & POLLNVAL)); // closed while armed + if (!(revents & POLLNVAL)) { ready.push_back(tokens_[i]); } + remove_at(i); + } + return woken; +} + +inline void PollPoller::wake() noexcept { + // One pending byte ends a wait(), so later calls skip the syscall. + if (wake_pending_.exchange(true)) { return; } + const char c = 1; + send_socket(wake_write_, &c, 1, CPPHTTPLIB_SEND_FLAGS); +} + +inline std::unique_ptr make_poller() { return PollPoller::create(); } + inline bool bind_ip_address(socket_t sock, const std::string &host) { struct addrinfo hints; struct addrinfo *result; diff --git a/test/test.cc b/test/test.cc index 64f37dee..ae16e172 100644 --- a/test/test.cc +++ b/test/test.cc @@ -33916,3 +33916,201 @@ TEST(WebSocketProxyTest, WssTunnelsThroughConnect) { EXPECT_EQ(1, proxy.connect_hits()); } #endif + +// --------------------------------------------------------------------------- +// Poller +// --------------------------------------------------------------------------- + +namespace poller_test { + +struct PollerBackend { + const char *name; + std::unique_ptr (*create)(); +}; + +void PrintTo(const PollerBackend &backend, std::ostream *os) { + *os << backend.name; +} + +// Every backend runs the same contract tests. A new one is added here only. +std::vector poller_backends() { + return {{"poll", &detail::PollPoller::create}}; +} + +// A descriptor whose readability the test controls. +struct TestSocketPair { + socket_t fd[2] = {INVALID_SOCKET, INVALID_SOCKET}; + + TestSocketPair() { detail::create_socket_pair(fd); } + ~TestSocketPair() { + for (auto s : fd) { + if (s != INVALID_SOCKET) { detail::close_socket(s); } + } + } + + bool ok() const { return fd[0] != INVALID_SOCKET; } + socket_t reader() const { return fd[0]; } + void make_readable() { + const char c = 1; + detail::send_socket(fd[1], &c, 1, 0); + } + void close_writer() { + detail::close_socket(fd[1]); + fd[1] = INVALID_SOCKET; + } +}; + +using Tokens = std::vector; + +class PollerTest : public ::testing::TestWithParam { +protected: + void SetUp() override { + poller_ = GetParam().create(); + ASSERT_TRUE(poller_ != nullptr); + } + + Tokens wait_for(int timeout_ms) { + Tokens ready; + poller_->wait(timeout_ms, ready); + std::sort(ready.begin(), ready.end()); + return ready; + } + + std::unique_ptr poller_; +}; + +} // namespace poller_test + +using poller_test::PollerTest; +using poller_test::TestSocketPair; +using poller_test::Tokens; + +INSTANTIATE_TEST_SUITE_P( + Backends, PollerTest, ::testing::ValuesIn(poller_test::poller_backends()), + [](const ::testing::TestParamInfo &p) { + return std::string(p.param.name); + }); + +TEST_P(PollerTest, DeliversOnceThenStaysDisarmedUntilRearmed) { + TestSocketPair sp; + ASSERT_TRUE(sp.ok()); + ASSERT_TRUE(poller_->arm(sp.reader(), 7)); + EXPECT_EQ(Tokens{}, wait_for(0)); + + sp.make_readable(); + EXPECT_EQ(Tokens{7}, wait_for(1000)); + EXPECT_EQ(Tokens{}, wait_for(0)); // still readable, but disarmed + + ASSERT_TRUE(poller_->arm(sp.reader(), 8)); + EXPECT_EQ(Tokens{8}, wait_for(1000)); +} + +TEST_P(PollerTest, DisarmedDescriptorIsNotDelivered) { + TestSocketPair sp; + ASSERT_TRUE(sp.ok()); + ASSERT_TRUE(poller_->arm(sp.reader(), 1)); + poller_->disarm(sp.reader()); + poller_->disarm(sp.reader()); // disarming twice is harmless + sp.make_readable(); + EXPECT_EQ(Tokens{}, wait_for(0)); +} + +TEST_P(PollerTest, WaitHonoursItsTimeout) { + TestSocketPair sp; + ASSERT_TRUE(sp.ok()); + ASSERT_TRUE(poller_->arm(sp.reader(), 1)); + + auto start = std::chrono::steady_clock::now(); + EXPECT_EQ(Tokens{}, wait_for(30)); + auto elapsed = std::chrono::steady_clock::now() - start; + EXPECT_GE(elapsed, std::chrono::milliseconds(25)); + EXPECT_LT(elapsed, std::chrono::seconds(1)); +} + +TEST_P(PollerTest, OnlyTheReadyDescriptorsAreDelivered) { + std::vector> sps; + for (detail::Poller::Token i = 0; i < 8; i++) { + sps.emplace_back(new TestSocketPair()); + ASSERT_TRUE(sps.back()->ok()); + ASSERT_TRUE(poller_->arm(sps.back()->reader(), i)); + } + + sps[0]->make_readable(); + sps[3]->make_readable(); + sps[7]->make_readable(); + EXPECT_EQ((Tokens{0, 3, 7}), wait_for(1000)); + + // The others are still armed, the delivered ones are not. + sps[1]->make_readable(); + EXPECT_EQ(Tokens{1}, wait_for(1000)); + EXPECT_EQ(Tokens{}, wait_for(0)); +} + +TEST_P(PollerTest, StaysConsistentAfterOtherDescriptorsWereDelivered) { + TestSocketPair s0, s1, s2; + ASSERT_TRUE(s0.ok() && s1.ok() && s2.ok()); + ASSERT_TRUE(poller_->arm(s0.reader(), 0)); + ASSERT_TRUE(poller_->arm(s1.reader(), 1)); + ASSERT_TRUE(poller_->arm(s2.reader(), 2)); + + // A delivery may move another entry inside the poller. + s0.make_readable(); + EXPECT_EQ(Tokens{0}, wait_for(1000)); + + // The entries left must still be found by descriptor. + poller_->disarm(s2.reader()); + s1.make_readable(); + s2.make_readable(); + EXPECT_EQ(Tokens{1}, wait_for(1000)); +} + +TEST_P(PollerTest, PeerHangUpCountsAsReadable) { + TestSocketPair sp; + ASSERT_TRUE(sp.ok()); + ASSERT_TRUE(poller_->arm(sp.reader(), 5)); + sp.close_writer(); + EXPECT_EQ(Tokens{5}, wait_for(1000)); + + char c; + EXPECT_EQ(0, detail::read_socket(sp.reader(), &c, 1, 0)); // EOF +} + +TEST_P(PollerTest, WakeEndsABlockedWait) { + std::thread waker([&] { + std::this_thread::sleep_for(std::chrono::milliseconds(20)); + poller_->wake(); + }); + + Tokens ready; + auto start = std::chrono::steady_clock::now(); + EXPECT_TRUE(poller_->wait(5000, ready)); // only the waker ends this early + waker.join(); + EXPECT_TRUE(ready.empty()); + EXPECT_LT(std::chrono::steady_clock::now() - start, std::chrono::seconds(1)); +} + +TEST_P(PollerTest, WakeBeforeWaitIsNotLost) { + poller_->wake(); // e.g. stop() running before the reactor reaches wait() + Tokens ready; + EXPECT_TRUE(poller_->wait(1000, ready)); +} + +TEST_P(PollerTest, WakesCoalesceAndAreConsumed) { + for (int i = 0; i < 1000; i++) { + poller_->wake(); + } + Tokens ready; + EXPECT_TRUE(poller_->wait(0, ready)); + EXPECT_FALSE(poller_->wait(0, ready)); + + poller_->wake(); + EXPECT_TRUE(poller_->wait(0, ready)); +} + +TEST(PollerFactoryTest, MakePollerWorks) { + auto poller = detail::make_poller(); + ASSERT_TRUE(poller != nullptr); + poller->wake(); + std::vector ready; + EXPECT_TRUE(poller->wait(1000, ready)); +}