Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
46 changes: 27 additions & 19 deletions include/mp/proxy-io.h
Original file line number Diff line number Diff line change
Expand Up @@ -263,12 +263,17 @@ class EventLoop
~EventLoop();

//! Run event loop. Does not return until shutdown. This should only be
//! called once from the m_thread_id thread. This will block until
//! the m_num_refs reference count is 0.
//! called once from the m_thread_id thread. This will block until the
//! m_num_refs reference count drops to 0 and there are no pending async
//! cleanup functions. This only happens once and loop() returns right
//! after, so new EventLoopRef instances should only be created by code
//! that already holds a reference, or is kept alive by one.
void loop();

//! Run function on event loop thread. Does not return until function completes.
//! Must be called while the loop() function is active.
//! Must be called while the loop() function is active, and the caller must
//! prevent loop() from returning until sync() returns, normally by holding
//! an EventLoopRef.
void sync(kj::FunctionParam<void()> fn);

//! Register cleanup function to run on asynchronous worker thread without
Expand Down Expand Up @@ -308,35 +313,34 @@ class EventLoop
//! method has not been called.
std::thread m_async_thread;

//! Callback function to run on event loop thread during sync() call.
kj::FunctionParam<void()>* m_sync_fn MP_GUARDED_BY(m_mutex) = nullptr;

//! Callback functions to run on async thread.
std::optional<CleanupList> m_async_fns MP_GUARDED_BY(m_mutex);

//! Socket pair used to post and wait for wakeups to the event loop thread.
kj::Own<kj::AsyncIoStream> m_wait_stream;
kj::Own<kj::AsyncIoStream> m_post_stream;

//! Synchronous writer used to write to m_post_stream.
kj::Own<kj::OutputStream> m_post_writer;

//! Number of EventLoopRef instances referencing this event loop. This is a
//! sum of the number of client and server objects (Connection, ProxyClient,
//! ProxyServer) using the loop, plus temporary references held while
//! posting functions to the loop, plus any references held by external code
//! to keep the loop running. The loop() method exits when this count drops
//! to 0 (and m_async_fns is empty).
//! ProxyServer) using the loop, plus a temporary reference held by the
//! async thread while it runs each cleanup function, plus any references
//! held by external code to keep the loop running. The loop() method exits
//! when this count drops to 0 (and m_async_fns is empty).
int m_num_refs MP_GUARDED_BY(m_mutex) = 0;

//! Mutex and condition variable used to post tasks to event loop and async
//! thread.
//! Mutex guarding the reference count and async cleanup list.
Mutex m_mutex;
//! Condition variable used to wake up the async thread when a cleanup
//! function is added or when loop() returns.
std::condition_variable m_cv;

//! Capnp IO context.
kj::AsyncIoContext m_io_context;

//! Executor for the event loop thread. sync() uses it to run functions on
//! the event loop thread when called from other threads.
const kj::Executor& m_executor;

//! Promise that loop() waits on before returning. EventLoopRef::reset()
//! fulfills it when done() becomes true.
kj::PromiseCrossThreadFulfillerPair<void> m_stop_promise_fulfiller_pair;

//! Capnp error handler. Needs to outlive m_task_set.
LoggingErrorHandler m_error_handler{*this};

Expand Down Expand Up @@ -994,6 +998,10 @@ std::pair<ProxyServer<InitInterface>*, EventLoop::Connections::iterator> ServeSt

//! Given listening socket identifier and an init object, handle incoming
//! connections and requests by calling methods on the Init object.
//!
//! The listener does not hold an EventLoopRef, so the caller needs to hold
//! one for as long as connections should be accepted. Otherwise the event
//! loop exits after the last accepted connection is closed.
template <typename InitInterface, typename InitImpl>
void ListenConnections(EventLoop& loop, SocketId fd, InitImpl& init, std::optional<size_t> max_connections = std::nullopt)
{
Expand Down
2 changes: 1 addition & 1 deletion include/mp/proxy.h
Original file line number Diff line number Diff line change
Expand Up @@ -60,7 +60,7 @@ class EventLoopRef
~EventLoopRef() { reset(); }
EventLoop& operator*() const { assert(m_loop); return *m_loop; }
EventLoop* operator->() const { assert(m_loop); return m_loop; }
void reset(bool relock=false);
void reset();

EventLoop* m_loop{nullptr};
Lock* m_lock{nullptr};
Expand Down
95 changes: 19 additions & 76 deletions src/mp/proxy.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -24,10 +24,10 @@
#include <kj/debug.h>
#include <kj/exception.h>
#include <kj/function.h>
#include <kj/io.h>
#include <kj/memory.h>
#include <kj/string.h>
#include <cstdint>
#include <cstring>
#include <map>
#include <memory>
#include <optional>
Expand Down Expand Up @@ -69,10 +69,7 @@ EventLoopRef::EventLoopRef(EventLoop& loop, Lock* lock) : m_loop(&loop), m_lock(
m_loop->m_num_refs += 1;
}

// Due to the conditionals in this function, MP_NO_TSA is required to avoid
// error "error: mutex 'loop_lock' is not held on every path through here
// [-Wthread-safety-analysis]"
void EventLoopRef::reset(bool relock) MP_NO_TSA
void EventLoopRef::reset()
{
if (auto* loop{m_loop}) {
m_loop = nullptr;
Expand All @@ -81,25 +78,11 @@ void EventLoopRef::reset(bool relock) MP_NO_TSA
assert(loop->m_num_refs > 0);
loop->m_num_refs -= 1;
if (loop->done()) {
loop->m_cv.notify_all();
// Capture loop->m_post_writer pointer before releasing the lock.
// The pointer can't actually change before the write() call below,
// but copying it with the lock held instead of accessing it
// directly below prevents TSAN false positives because TSAN is
// unaware of socketpair write() synchronization and might falsely
// report the pointer being used in this thread and assigned in the
// other thread without synchronization between.
kj::OutputStream* post_writer{loop->m_post_writer.get()};
loop_lock->unlock();
char buffer = 0;
// It safe to access post_writer here because the loop can't
// exit until this write takes place. See "Intentionally do not
// break..." comment in EventLoop::loop
post_writer->write(&buffer, 1);
// By default, do not try to relock `loop_lock` after writing,
// because the event loop could wake up and destroy itself and the
// mutex might no longer exist.
if (relock) loop_lock->lock();
// Wake up EventLoop::loop() so it can exit. This is called with
// m_mutex held, and loop() locks m_mutex before returning, so the
// loop can't exit and destroy the fulfiller while fulfill() is
// running. Do not unlock m_mutex before this call.
loop->m_stop_promise_fulfiller_pair.fulfiller->fulfill();
Comment thread
ryanofsky marked this conversation as resolved.
Resolved
}
}
}
Expand Down Expand Up @@ -257,28 +240,17 @@ void EventLoop::addAsyncCleanup(std::function<void()> fn)
EventLoop::EventLoop(const char* exe_name, LogOptions log_opts, void* context)
: m_exe_name(exe_name),
m_io_context(kj::setupAsyncIo()),
m_executor(kj::getCurrentThreadExecutor()),
m_stop_promise_fulfiller_pair(kj::newPromiseAndCrossThreadFulfiller<void>()),
m_task_set(new kj::TaskSet(m_error_handler)),
m_log_opts(std::move(log_opts)),
m_context(context)
{
auto pipe = m_io_context.provider->newTwoWayPipe();
m_wait_stream = kj::mv(pipe.ends[0]);
m_post_stream = kj::mv(pipe.ends[1]);
KJ_IF_MAYBE(fd, m_post_stream->getFd()) {
m_post_writer = kj::heap<kj::FdOutputStream>(*fd);
} else {
throw std::logic_error("Could not get file descriptor for new pipe.");
}
}
m_context(context) {}

EventLoop::~EventLoop()
{
if (m_async_thread.joinable()) m_async_thread.join();
const Lock lock(m_mutex);
KJ_ASSERT(m_sync_fn == nullptr);
KJ_ASSERT(!m_async_fns);
KJ_ASSERT(!m_wait_stream);
KJ_ASSERT(!m_post_stream);
KJ_ASSERT(m_num_refs == 0);

// Spin event loop. wait for any promises triggered by RPC shutdown.
Expand All @@ -298,37 +270,13 @@ void EventLoop::loop()
m_async_fns.emplace();
}

kj::Own<kj::AsyncIoStream>& wait_stream{m_wait_stream};
char buffer = 0;
for (;;) {
const size_t read_bytes = wait_stream->read(&buffer, 0, 1).wait(m_io_context.waitScope);
if (read_bytes != 1) throw std::logic_error("EventLoop wait_stream closed unexpectedly");
Lock lock(m_mutex);
if (m_sync_fn) {
// m_sync_fn throwing is never expected. If it does happen, the caller
// of EventLoop::sync() will return without any indication of failure,
// which will likely cause other bugs. Log the error and continue.
KJ_IF_MAYBE(exception, kj::runCatchingExceptions([&]() MP_REQUIRES(m_mutex) { Unlock(lock, *m_sync_fn); })) {
MP_LOG(*this, Log::Error) << "EventLoop: m_sync_fn threw: " << kj::str(*exception).cStr();
}
m_sync_fn = nullptr;
m_cv.notify_all();
} else if (done()) {
// Intentionally do not break if m_sync_fn was set, even if done()
// would return true, to ensure that the sync() m_post_writer->write()
// call always succeeds and the loop does not exit between the time
// that the done condition is set and the write call is made.
break;
}
}
// Block execution here until all references are dropped
m_stop_promise_fulfiller_pair.promise.wait(m_io_context.waitScope);
Comment thread
ryanofsky marked this conversation as resolved.
Resolved

MP_LOG(*this, Log::Info) << "EventLoop::loop done, cancelling event listeners.";
m_task_set.reset();
MP_LOG(*this, Log::Info) << "EventLoop::loop bye.";
wait_stream = nullptr;
const Lock lock(m_mutex);
m_post_writer = nullptr;
m_wait_stream = nullptr;
m_post_stream = nullptr;
m_async_fns.reset();
m_cv.notify_all();
}
Expand All @@ -339,15 +287,12 @@ void EventLoop::sync(kj::FunctionParam<void()> fn)
fn();
return;
}
Lock lock(m_mutex);
EventLoopRef ref(*this, &lock);
m_cv.wait(lock.m_lock, [this]() MP_REQUIRES(m_mutex) { return m_sync_fn == nullptr; });
m_sync_fn = &fn;
Unlock(lock, [&] {
char buffer = 0;
m_post_writer->write(&buffer, 1);
});
m_cv.wait(lock.m_lock, [this, &fn]() MP_REQUIRES(m_mutex) { return m_sync_fn != &fn; });
// fn throwing is never expected. If it does happen, the caller of
// EventLoop::sync() will return without any indication of failure, which
// will likely cause other bugs. Log the error and continue.
KJ_IF_MAYBE(exception, kj::runCatchingExceptions([&]() { m_executor.executeSync(fn); })) {
Comment thread
ryanofsky marked this conversation as resolved.
Resolved
MP_LOG(*this, Log::Error) << "EventLoop: m_executor.executeSync threw: " << kj::str(*exception).cStr();
Comment thread
ryanofsky marked this conversation as resolved.
Resolved
}
Comment thread
xyzconstant marked this conversation as resolved.
Resolved
}

void EventLoop::startAsyncThread()
Expand All @@ -366,8 +311,6 @@ void EventLoop::startAsyncThread()
const std::function<void()> fn = std::move(m_async_fns->front());
m_async_fns->pop_front();
Unlock(lock, fn);
// Important to relock because of the wait() call below.
ref.reset(/*relock=*/true);
// Continue without waiting in case there are more async_fns
continue;
}
Expand Down
Loading