From 5397870bca6015e1f55106544e5b763b8b3e048b Mon Sep 17 00:00:00 2001 From: songgaoye Date: Thu, 12 Nov 2026 10:49:05 +0800 Subject: [PATCH 1/3] fix(event-dispatcher): synchronize dispatcher shutdown state --- src/brpc/event_dispatcher.h | 5 ++- src/brpc/event_dispatcher_epoll.cpp | 12 +++--- src/brpc/event_dispatcher_kqueue.cpp | 12 +++--- test/brpc_event_dispatcher_unittest.cpp | 49 +++++++++++++++++++++++++ 4 files changed, 62 insertions(+), 16 deletions(-) diff --git a/src/brpc/event_dispatcher.h b/src/brpc/event_dispatcher.h index 33f3537ebb..1ab5b66d60 100644 --- a/src/brpc/event_dispatcher.h +++ b/src/brpc/event_dispatcher.h @@ -20,6 +20,7 @@ #define BRPC_EVENT_DISPATCHER_H #include // DECLARE_bool +#include "butil/atomicops.h" // butil::atomic #include "butil/macros.h" // DISALLOW_COPY_AND_ASSIGN #include "bthread/types.h" // bthread_t, bthread_attr_t #include "brpc/versioned_ref_with_id.h" @@ -179,8 +180,8 @@ template friend class IOEvent; // The epoll/kqueue fd to watch events. int _event_dispatcher_fd; - // false unless Stop() is called. - volatile bool _stop; + // False until Stop() publishes shutdown. + butil::atomic _stop; // identifier of hosting bthread bthread_t _tid; diff --git a/src/brpc/event_dispatcher_epoll.cpp b/src/brpc/event_dispatcher_epoll.cpp index 1a3e74ef8e..e2149d161b 100644 --- a/src/brpc/event_dispatcher_epoll.cpp +++ b/src/brpc/event_dispatcher_epoll.cpp @@ -94,11 +94,12 @@ int EventDispatcher::Start(const bthread_attr_t* thread_attr) { } bool EventDispatcher::Running() const { - return !_stop && _event_dispatcher_fd >= 0 && _tid != 0; + return !_stop.load(butil::memory_order_acquire) && + _event_dispatcher_fd >= 0 && _tid != 0; } void EventDispatcher::Stop() { - _stop = true; + _stop.store(true, butil::memory_order_release); if (_event_dispatcher_fd >= 0) { epoll_event evt = { EPOLLOUT, { nullptr } }; @@ -201,7 +202,7 @@ void* EventDispatcher::RunThis(void* arg) { } void EventDispatcher::Run() { - while (!_stop) { + while (!_stop.load(butil::memory_order_acquire)) { epoll_event e[32]; #ifdef BRPC_ADDITIONAL_EPOLL // Performance downgrades in examples. @@ -212,10 +213,7 @@ void EventDispatcher::Run() { #else const int n = epoll_wait(_event_dispatcher_fd, e, ARRAY_SIZE(e), -1); #endif - if (_stop) { - // epoll_ctl/epoll_wait should have some sort of memory fencing - // guaranteeing that we(after epoll_wait) see _stop set before - // epoll_ctl. + if (_stop.load(butil::memory_order_acquire)) { break; } if (n < 0) { diff --git a/src/brpc/event_dispatcher_kqueue.cpp b/src/brpc/event_dispatcher_kqueue.cpp index 8bec41aa8f..897cdc59af 100644 --- a/src/brpc/event_dispatcher_kqueue.cpp +++ b/src/brpc/event_dispatcher_kqueue.cpp @@ -95,11 +95,12 @@ int EventDispatcher::Start(const bthread_attr_t* thread_attr) { } bool EventDispatcher::Running() const { - return !_stop && _event_dispatcher_fd >= 0 && _tid != 0; + return !_stop.load(butil::memory_order_acquire) && + _event_dispatcher_fd >= 0 && _tid != 0; } void EventDispatcher::Stop() { - _stop = true; + _stop.store(true, butil::memory_order_release); if (_event_dispatcher_fd >= 0) { struct kevent kqueue_event; @@ -191,13 +192,10 @@ void* EventDispatcher::RunThis(void* arg) { } void EventDispatcher::Run() { - while (!_stop) { + while (!_stop.load(butil::memory_order_acquire)) { struct kevent e[32]; int n = kevent(_event_dispatcher_fd, nullptr, 0, e, ARRAY_SIZE(e), nullptr); - if (_stop) { - // EV_SET/kevent should have some sort of memory fencing - // guaranteeing that we(after kevent) see _stop set before - // EV_SET + if (_stop.load(butil::memory_order_acquire)) { break; } if (n < 0) { diff --git a/test/brpc_event_dispatcher_unittest.cpp b/test/brpc_event_dispatcher_unittest.cpp index 1825fe296d..1ac2c6e776 100644 --- a/test/brpc_event_dispatcher_unittest.cpp +++ b/test/brpc_event_dispatcher_unittest.cpp @@ -130,6 +130,55 @@ TEST_F(EventDispatcherTest, has_epollrdhup) { LOG(INFO) << brpc::has_epollrdhup; } +TEST_F(EventDispatcherTest, start_stop_updates_running_state) { + brpc::EventDispatcher dispatcher; + ASSERT_EQ(0, dispatcher.Start(nullptr)); + ASSERT_TRUE(dispatcher.Running()); + dispatcher.Stop(); + dispatcher.Join(); + ASSERT_FALSE(dispatcher.Running()); +} + +struct DispatcherStopRaceArgs { + brpc::EventDispatcher* dispatcher; + butil::atomic reader_started; + butil::atomic reader_finished; + + DispatcherStopRaceArgs() + : dispatcher(nullptr) + , reader_started(false) + , reader_finished(false) {} +}; + +void* poll_dispatcher_running(void* arg) { + DispatcherStopRaceArgs* args = static_cast(arg); + args->reader_started.store(true, butil::memory_order_release); + const int kRunningChecks = 100000; + for (int i = 0; i < kRunningChecks; ++i) { + args->dispatcher->Running(); + } + args->reader_finished.store(true, butil::memory_order_release); + return nullptr; +} + +// Under TSAN, this reports the Running()/Stop() race when _stop is volatile. +TEST_F(EventDispatcherTest, stop_is_safe_with_concurrent_running) { + brpc::EventDispatcher dispatcher; + ASSERT_EQ(0, dispatcher.Start(nullptr)); + + DispatcherStopRaceArgs args; + args.dispatcher = &dispatcher; + pthread_t tid; + ASSERT_EQ(0, pthread_create(&tid, nullptr, poll_dispatcher_running, + &args)); + while (!args.reader_started.load(butil::memory_order_acquire)) { + } + dispatcher.Stop(); + ASSERT_EQ(0, pthread_join(tid, nullptr)); + EXPECT_TRUE(args.reader_finished.load(butil::memory_order_acquire)); + dispatcher.Join(); +} + TEST_F(EventDispatcherTest, versioned_ref) { butil::atomic versioned_ref(2); versioned_ref.fetch_add(brpc::MakeVRef(0, -1), From 7331d937a161bd3006929a9c529eba0f84f5a36e Mon Sep 17 00:00:00 2001 From: songgaoye Date: Thu, 12 Nov 2026 11:52:06 +0800 Subject: [PATCH 2/3] test(event-dispatcher): synchronize stop race regression --- test/brpc_event_dispatcher_unittest.cpp | 18 +++++++++++++++--- 1 file changed, 15 insertions(+), 3 deletions(-) diff --git a/test/brpc_event_dispatcher_unittest.cpp b/test/brpc_event_dispatcher_unittest.cpp index 1ac2c6e776..781c839904 100644 --- a/test/brpc_event_dispatcher_unittest.cpp +++ b/test/brpc_event_dispatcher_unittest.cpp @@ -142,21 +142,29 @@ TEST_F(EventDispatcherTest, start_stop_updates_running_state) { struct DispatcherStopRaceArgs { brpc::EventDispatcher* dispatcher; butil::atomic reader_started; + butil::atomic stop_requested; + butil::atomic reader_polling; + butil::atomic stop_completed; butil::atomic reader_finished; DispatcherStopRaceArgs() : dispatcher(nullptr) , reader_started(false) + , stop_requested(false) + , reader_polling(false) + , stop_completed(false) , reader_finished(false) {} }; void* poll_dispatcher_running(void* arg) { DispatcherStopRaceArgs* args = static_cast(arg); args->reader_started.store(true, butil::memory_order_release); - const int kRunningChecks = 100000; - for (int i = 0; i < kRunningChecks; ++i) { - args->dispatcher->Running(); + while (!args->stop_requested.load(butil::memory_order_acquire)) { } + args->reader_polling.store(true, butil::memory_order_release); + do { + args->dispatcher->Running(); + } while (!args->stop_completed.load(butil::memory_order_acquire)); args->reader_finished.store(true, butil::memory_order_release); return nullptr; } @@ -173,7 +181,11 @@ TEST_F(EventDispatcherTest, stop_is_safe_with_concurrent_running) { &args)); while (!args.reader_started.load(butil::memory_order_acquire)) { } + args.stop_requested.store(true, butil::memory_order_release); + while (!args.reader_polling.load(butil::memory_order_acquire)) { + } dispatcher.Stop(); + args.stop_completed.store(true, butil::memory_order_release); ASSERT_EQ(0, pthread_join(tid, nullptr)); EXPECT_TRUE(args.reader_finished.load(butil::memory_order_acquire)); dispatcher.Join(); From 4cb06693300fbfe7bdc21407e7b0c12c2f411ebc Mon Sep 17 00:00:00 2001 From: songgaoye Date: Mon, 16 Nov 2026 19:58:56 +0800 Subject: [PATCH 3/3] Use relaxed ordering for EventDispatcher stop flag --- src/brpc/event_dispatcher.h | 2 +- src/brpc/event_dispatcher_epoll.cpp | 8 ++--- src/brpc/event_dispatcher_kqueue.cpp | 8 ++--- test/brpc_event_dispatcher_unittest.cpp | 48 +++++++++---------------- 4 files changed, 25 insertions(+), 41 deletions(-) diff --git a/src/brpc/event_dispatcher.h b/src/brpc/event_dispatcher.h index 1ab5b66d60..2a8c74ad43 100644 --- a/src/brpc/event_dispatcher.h +++ b/src/brpc/event_dispatcher.h @@ -180,7 +180,7 @@ template friend class IOEvent; // The epoll/kqueue fd to watch events. int _event_dispatcher_fd; - // False until Stop() publishes shutdown. + // Set by Stop() to request shutdown. butil::atomic _stop; // identifier of hosting bthread diff --git a/src/brpc/event_dispatcher_epoll.cpp b/src/brpc/event_dispatcher_epoll.cpp index e2149d161b..1519f8d82b 100644 --- a/src/brpc/event_dispatcher_epoll.cpp +++ b/src/brpc/event_dispatcher_epoll.cpp @@ -94,12 +94,12 @@ int EventDispatcher::Start(const bthread_attr_t* thread_attr) { } bool EventDispatcher::Running() const { - return !_stop.load(butil::memory_order_acquire) && + return !_stop.load(butil::memory_order_relaxed) && _event_dispatcher_fd >= 0 && _tid != 0; } void EventDispatcher::Stop() { - _stop.store(true, butil::memory_order_release); + _stop.store(true, butil::memory_order_relaxed); if (_event_dispatcher_fd >= 0) { epoll_event evt = { EPOLLOUT, { nullptr } }; @@ -202,7 +202,7 @@ void* EventDispatcher::RunThis(void* arg) { } void EventDispatcher::Run() { - while (!_stop.load(butil::memory_order_acquire)) { + while (!_stop.load(butil::memory_order_relaxed)) { epoll_event e[32]; #ifdef BRPC_ADDITIONAL_EPOLL // Performance downgrades in examples. @@ -213,7 +213,7 @@ void EventDispatcher::Run() { #else const int n = epoll_wait(_event_dispatcher_fd, e, ARRAY_SIZE(e), -1); #endif - if (_stop.load(butil::memory_order_acquire)) { + if (_stop.load(butil::memory_order_relaxed)) { break; } if (n < 0) { diff --git a/src/brpc/event_dispatcher_kqueue.cpp b/src/brpc/event_dispatcher_kqueue.cpp index 897cdc59af..3e3100ea7b 100644 --- a/src/brpc/event_dispatcher_kqueue.cpp +++ b/src/brpc/event_dispatcher_kqueue.cpp @@ -95,12 +95,12 @@ int EventDispatcher::Start(const bthread_attr_t* thread_attr) { } bool EventDispatcher::Running() const { - return !_stop.load(butil::memory_order_acquire) && + return !_stop.load(butil::memory_order_relaxed) && _event_dispatcher_fd >= 0 && _tid != 0; } void EventDispatcher::Stop() { - _stop.store(true, butil::memory_order_release); + _stop.store(true, butil::memory_order_relaxed); if (_event_dispatcher_fd >= 0) { struct kevent kqueue_event; @@ -192,10 +192,10 @@ void* EventDispatcher::RunThis(void* arg) { } void EventDispatcher::Run() { - while (!_stop.load(butil::memory_order_acquire)) { + while (!_stop.load(butil::memory_order_relaxed)) { struct kevent e[32]; int n = kevent(_event_dispatcher_fd, nullptr, 0, e, ARRAY_SIZE(e), nullptr); - if (_stop.load(butil::memory_order_acquire)) { + if (_stop.load(butil::memory_order_relaxed)) { break; } if (n < 0) { diff --git a/test/brpc_event_dispatcher_unittest.cpp b/test/brpc_event_dispatcher_unittest.cpp index 781c839904..c3795715a9 100644 --- a/test/brpc_event_dispatcher_unittest.cpp +++ b/test/brpc_event_dispatcher_unittest.cpp @@ -135,59 +135,43 @@ TEST_F(EventDispatcherTest, start_stop_updates_running_state) { ASSERT_EQ(0, dispatcher.Start(nullptr)); ASSERT_TRUE(dispatcher.Running()); dispatcher.Stop(); + ASSERT_FALSE(dispatcher.Running()); dispatcher.Join(); ASSERT_FALSE(dispatcher.Running()); } struct DispatcherStopRaceArgs { brpc::EventDispatcher* dispatcher; - butil::atomic reader_started; - butil::atomic stop_requested; - butil::atomic reader_polling; - butil::atomic stop_completed; - butil::atomic reader_finished; + butil::atomic call_running; DispatcherStopRaceArgs() : dispatcher(nullptr) - , reader_started(false) - , stop_requested(false) - , reader_polling(false) - , stop_completed(false) - , reader_finished(false) {} + , call_running(false) {} }; -void* poll_dispatcher_running(void* arg) { +void* call_dispatcher_running(void* arg) { DispatcherStopRaceArgs* args = static_cast(arg); - args->reader_started.store(true, butil::memory_order_release); - while (!args->stop_requested.load(butil::memory_order_acquire)) { - } - args->reader_polling.store(true, butil::memory_order_release); - do { - args->dispatcher->Running(); - } while (!args->stop_completed.load(butil::memory_order_acquire)); - args->reader_finished.store(true, butil::memory_order_release); + while (!args->call_running.load(butil::memory_order_relaxed)) { + } + args->dispatcher->Running(); return nullptr; } -// Under TSAN, this reports the Running()/Stop() race when _stop is volatile. -TEST_F(EventDispatcherTest, stop_is_safe_with_concurrent_running) { +// The relaxed handoff guarantees that Running() is called after Stop() without +// creating a happens-before edge. Under TSAN, this reports the Running()/Stop() +// race when _stop is non-atomic. +TEST_F(EventDispatcherTest, running_is_safe_after_stop) { brpc::EventDispatcher dispatcher; ASSERT_EQ(0, dispatcher.Start(nullptr)); DispatcherStopRaceArgs args; args.dispatcher = &dispatcher; pthread_t tid; - ASSERT_EQ(0, pthread_create(&tid, nullptr, poll_dispatcher_running, + ASSERT_EQ(0, pthread_create(&tid, nullptr, call_dispatcher_running, &args)); - while (!args.reader_started.load(butil::memory_order_acquire)) { - } - args.stop_requested.store(true, butil::memory_order_release); - while (!args.reader_polling.load(butil::memory_order_acquire)) { - } dispatcher.Stop(); - args.stop_completed.store(true, butil::memory_order_release); + args.call_running.store(true, butil::memory_order_relaxed); ASSERT_EQ(0, pthread_join(tid, nullptr)); - EXPECT_TRUE(args.reader_finished.load(butil::memory_order_acquire)); dispatcher.Join(); } @@ -708,7 +692,7 @@ void* stop_and_join(void* arg) { StopArgs* args = static_cast(arg); args->server->Stop(0); args->server->Join(); - args->done.store(true, butil::memory_order_release); + args->done.store(true, butil::memory_order_relaxed); return nullptr; } @@ -766,11 +750,11 @@ TEST_F(EventDispatcherTest, server_with_fewer_threads_than_dispatchers_can_quit) pthread_t th; ASSERT_EQ(0, pthread_create(&th, nullptr, stop_and_join, &args)); int64_t deadline_us = butil::gettimeofday_us() + 10 * 1000000L; - while (!args.done.load(butil::memory_order_acquire) && + while (!args.done.load(butil::memory_order_relaxed) && butil::gettimeofday_us() < deadline_us) { usleep(10000); } - bool done = args.done.load(butil::memory_order_acquire); + bool done = args.done.load(butil::memory_order_relaxed); if (!done) { EXPECT_TRUE(done) << "Server::Stop()/Join() did not finish in 10s, " "no worker available?";