Compare commits

...
Author SHA1 Message Date
yhirose 3d85cf56d6 Tidy two spots left from the keep-alive parking review
drain_and_close_socket() checks the size bound before it reads the clock,
which saves a clock read on a drain that stops at 1 MB, and the comment
on PollPoller::fds_ fits on one line. Nothing else changes.
2026-11-21 23:22:06 -05:00
yhirose 0fe58217ea Let the parking loop wait without a cap when nothing is due
parking_loop capped every Poller::wait() at one minute only to keep the
millisecond timeout within an int, so an idle server woke once a minute
for nothing.

detail::poll_timeout_until() turns a deadline into the timeout instead:
-1 when there is none, which Poller::wait() already defines as waiting
until a descriptor is ready or wake() is called, otherwise whole
milliseconds, rounded up and capped at INT_MAX. The rounding is now
exact: adding 999 us turned a deadline 1 ns away into a timeout of 0.

The loop relies on a negative timeout for the first time, so the Poller
contract tests now check it on every backend.
2026-11-21 23:22:06 -05:00
2 changed files with 51 additions and 13 deletions

No files matched your search

+23 -13
View File
@@ -4034,8 +4034,7 @@ private:
PollerWaker waker_;
// fds_[0] is the waker's, which is always armed; tokens_[i] belongs to
// fds_[i].
// fds_[0] is the waker's, always armed; tokens_[i] belongs to fds_[i].
std::vector<struct pollfd> fds_;
std::vector<Token> tokens_;
std::unordered_map<socket_t, size_t> index_;
@@ -4088,6 +4087,11 @@ private:
// The best poller for this platform, or nullptr when it cannot be created.
std::unique_ptr<Poller> make_poller();
// The Poller::wait() timeout until `deadline`: -1 for time_point::max(),
// otherwise whole milliseconds, rounded up and capped at INT_MAX.
int poll_timeout_until(std::chrono::steady_clock::time_point deadline,
std::chrono::steady_clock::time_point now);
class BufferStream final : public Stream {
public:
BufferStream() = default;
@@ -7379,7 +7383,7 @@ inline void drain_and_close_socket(socket_t sock,
const auto n = read_socket(sock, buf, sizeof(buf), CPPHTTPLIB_RECV_FLAGS);
if (n <= 0) { break; }
total += static_cast<size_t>(n);
} while (usec_left() > 0 && total < size_t(1024u * 1024u)); // bound #2
} while (total < size_t(1024u * 1024u) && usec_left() > 0); // bound #2
shutdown_socket(sock);
close_socket(sock);
@@ -8262,6 +8266,18 @@ inline std::unique_ptr<Poller> make_poller() {
return PollPoller::create();
}
inline int poll_timeout_until(std::chrono::steady_clock::time_point deadline,
std::chrono::steady_clock::time_point now) {
using namespace std::chrono;
if (deadline == (steady_clock::time_point::max)()) { return -1; }
if (deadline <= now) { return 0; }
const auto left = deadline - now;
auto msec = duration_cast<milliseconds>(left);
if (msec < left) { msec += milliseconds(1); }
const auto cap = milliseconds((std::numeric_limits<int>::max)());
return static_cast<int>((std::min)(msec, cap).count());
}
inline bool bind_ip_address(socket_t sock, const std::string &host) {
struct addrinfo hints;
struct addrinfo *result;
@@ -16576,16 +16592,10 @@ inline bool Server::parking_loop(TaskQueue &task_queue) {
poller.arm(listen_sock, listen_token) ? never : now + check_interval;
}
// At most a minute, which keeps the timeout below within an int.
auto until = (std::min)({st.next_deadline(), listen_rearm_at, next_idle,
st.backlog.empty() ? never : now + check_interval,
now + std::chrono::seconds(60)});
// Rounded up, so that the wait does not end just short of the deadline.
auto timeout = std::chrono::duration_cast<std::chrono::milliseconds>(
until - now + std::chrono::microseconds(999));
poller.wait(static_cast<int>((std::max)(timeout.count(),
std::chrono::milliseconds::rep(0))),
ready);
auto until =
(std::min)({st.next_deadline(), listen_rearm_at, next_idle,
st.backlog.empty() ? never : now + check_interval});
poller.wait(detail::poll_timeout_until(until, now), ready);
if (svr_sock_ != listen_sock) { break; }
now = Clock::now();
+28
View File
@@ -34049,6 +34049,20 @@ TEST_P(PollerTest, WaitHonoursItsTimeout) {
EXPECT_LT(elapsed, std::chrono::seconds(1));
}
TEST_P(PollerTest, NegativeTimeoutWaitsUntilReady) {
TestSocketPair sp;
ASSERT_TRUE(sp.ok());
ASSERT_TRUE(poller_->arm(sp.reader(), 3));
std::thread writer([&] {
std::this_thread::sleep_for(std::chrono::milliseconds(20));
sp.make_readable();
});
auto ready = wait_for(-1);
writer.join();
EXPECT_EQ(Tokens{3}, ready);
}
TEST_P(PollerTest, OnlyTheReadyDescriptorsAreDelivered) {
std::vector<std::unique_ptr<TestSocketPair>> sps;
for (detail::Poller::Token i = 0; i < 8; i++) {
@@ -34167,6 +34181,20 @@ TEST(PollerFactoryTest, MakePollerWorks) {
EXPECT_TRUE(poller->wait(1000, ready));
}
TEST(PollTimeoutTest, LastsUntilTheDeadline) {
using namespace std::chrono;
const auto now = steady_clock::now();
auto timeout = [&](steady_clock::time_point deadline) {
return detail::poll_timeout_until(deadline, now);
};
EXPECT_EQ(-1, timeout((steady_clock::time_point::max)()));
EXPECT_EQ(0, timeout(now - milliseconds(5)));
EXPECT_EQ(1, timeout(now + nanoseconds(1)));
EXPECT_EQ(1, timeout(now + milliseconds(1)));
EXPECT_EQ(2, timeout(now + microseconds(1001)));
EXPECT_EQ((std::numeric_limits<int>::max)(), timeout(now + hours(1000)));
}
// ---------------------------------------------------------------------------
// Keep-alive parking
// ---------------------------------------------------------------------------