summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorTobias Markmann <tm@ayena.de>2015-11-18 13:51:58 (GMT)
committerSwift Review <review@swift.im>2015-11-19 15:32:04 (GMT)
commitfcf6a898de9c4f89db5de686aa203b3a52c18029 (patch)
tree4df426d92600eba8d4d60a88faaff1d5839129b0 /Swiften/EventLoop/EventLoop.cpp
parentcda6fd478b3d8f7f30f771b18324db389a01b1b3 (diff)
downloadswift-fcf6a898de9c4f89db5de686aa203b3a52c18029.zip
swift-fcf6a898de9c4f89db5de686aa203b3a52c18029.tar.bz2
Redesign event loops to be thread-safe and deterministic
The new event loop design has a single event queue that is synchronized to protect against data races. The removal of events in the queue by EventOwner is deterministic. Test-Information: All unit and integration tests with TSAN and cxxflags=-DBOOST_SP_USE_PTHREADS on Debian 8.2 pass without reports. Multiple Swiften/QA/ClientTest/ClientTest runs under different CPU stress caused no TSAN reports on Debian 8.2. Swift itself only causes TSAN reports related to Qt itself, out of our control, and most likely false positives, i.e. TSAN not detecting the synchronization method inside Qt correctly. Unit tests pass without errors and successfully connected to Slimber on OS X 10.10.5. Change-Id: Ia1ed32ac2e758c5b9f86e0dac21362818740881e
Diffstat (limited to 'Swiften/EventLoop/EventLoop.cpp')
-rw-r--r--Swiften/EventLoop/EventLoop.cpp77
1 files changed, 38 insertions, 39 deletions
diff --git a/Swiften/EventLoop/EventLoop.cpp b/Swiften/EventLoop/EventLoop.cpp
index 0b50e82..d9a9081 100644
--- a/Swiften/EventLoop/EventLoop.cpp
+++ b/Swiften/EventLoop/EventLoop.cpp
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2010-2013 Isode Limited.
+ * Copyright (c) 2010-2015 Isode Limited.
* All rights reserved.
* See the COPYING file for more information.
*/
@@ -7,11 +7,12 @@
#include <Swiften/EventLoop/EventLoop.h>
#include <algorithm>
-#include <iostream>
#include <cassert>
+
#include <boost/bind.hpp>
-#include <boost/lambda/lambda.hpp>
#include <boost/lambda/bind.hpp>
+#include <boost/lambda/lambda.hpp>
+#include <boost/optional.hpp>
#include <boost/thread/locks.hpp>
#include <Swiften/Base/Log.h>
@@ -26,68 +27,66 @@ inline void invokeCallback(const Event& event) {
event.callback();
}
catch (const std::exception& e) {
- std::cerr << "Uncaught exception in event loop: " << e.what() << std::endl;
+ SWIFT_LOG(error) << "Uncaught exception in event loop: " << e.what() << std::endl;
}
catch (...) {
- std::cerr << "Uncaught non-exception in event loop" << std::endl;
+ SWIFT_LOG(error) << "Uncaught non-exception in event loop" << std::endl;
}
}
-EventLoop::EventLoop() : nextEventID_(0), handlingEvents_(false) {
+EventLoop::EventLoop() : nextEventID_(0) {
}
EventLoop::~EventLoop() {
}
-void EventLoop::handleEvent(const Event& event) {
- //SWIFT_LOG(debug) << "Handling event " << event.id << std::endl;
-
- if (handlingEvents_) {
- // We're being called recursively. Push in the list of events to
- // handle in the parent handleEvent()
- eventsToHandle_.push_back(event);
- return;
- }
-
- bool doCallback = false;
+void EventLoop::handleNextEvent() {
+ bool callEventPosted = false;
{
- boost::lock_guard<boost::mutex> lock(eventsMutex_);
- std::list<Event>::iterator i = std::find(events_.begin(), events_.end(), event);
- if (i != events_.end()) {
- doCallback = true;
- events_.erase(i);
+ boost::recursive_mutex::scoped_lock lock(removeEventsMutex_);
+ {
+ boost::optional<Event> nextEvent;
+ {
+ boost::recursive_mutex::scoped_lock lock(eventsMutex_);
+ if (!events_.empty()) {
+ nextEvent = events_.front();
+ events_.pop_front();
+ }
+ }
+ callEventPosted = !events_.empty();
+ if (nextEvent) {
+ invokeCallback(nextEvent.get());
+ }
}
+
}
- if (doCallback) {
- handlingEvents_ = true;
- invokeCallback(event);
-
- // Process events that were passed to handleEvent during the callback
- // (i.e. through recursive calls of handleEvent)
- while (!eventsToHandle_.empty()) {
- Event nextEvent = eventsToHandle_.front();
- eventsToHandle_.pop_front();
- invokeCallback(nextEvent);
- }
- handlingEvents_ = false;
+
+ if (callEventPosted) {
+ eventPosted();
}
}
void EventLoop::postEvent(boost::function<void ()> callback, boost::shared_ptr<EventOwner> owner) {
Event event(owner, callback);
+ bool callEventPosted = false;
{
- boost::lock_guard<boost::mutex> lock(eventsMutex_);
+ boost::recursive_mutex::scoped_lock lock(eventsMutex_);
+
+ callEventPosted = events_.empty();
+
event.id = nextEventID_;
nextEventID_++;
events_.push_back(event);
}
- //SWIFT_LOG(debug) << "Posting event " << event.id << std::endl;
- post(event);
+ if (callEventPosted) {
+ eventPosted();
+ }
}
void EventLoop::removeEventsFromOwner(boost::shared_ptr<EventOwner> owner) {
- boost::lock_guard<boost::mutex> lock(eventsMutex_);
- events_.remove_if(lambda::bind(&Event::owner, lambda::_1) == owner);
+ boost::recursive_mutex::scoped_lock removeLock(removeEventsMutex_);
+ boost::recursive_mutex::scoped_lock lock(eventsMutex_);
+ events_.remove_if(lambda::bind(&Event::owner, lambda::_1) == owner);
}
}