diff options
Diffstat (limited to 'source/Core/Broadcaster.cpp')
| -rw-r--r-- | source/Core/Broadcaster.cpp | 389 |
1 files changed, 233 insertions, 156 deletions
diff --git a/source/Core/Broadcaster.cpp b/source/Core/Broadcaster.cpp index 351487401f6b..30bc78b48220 100644 --- a/source/Core/Broadcaster.cpp +++ b/source/Core/Broadcaster.cpp @@ -15,23 +15,26 @@ // Project includes #include "lldb/Core/Log.h" #include "lldb/Core/Event.h" +#include "lldb/Core/Listener.h" #include "lldb/Core/StreamString.h" using namespace lldb; using namespace lldb_private; -Broadcaster::Broadcaster (BroadcasterManager *manager, const char *name) : - m_broadcaster_name (name), - m_listeners (), - m_listeners_mutex (Mutex::eMutexTypeRecursive), - m_hijacking_listeners(), - m_hijacking_masks(), - m_manager (manager) +Broadcaster::Broadcaster(BroadcasterManagerSP manager_sp, const char *name) : + m_broadcaster_sp(new BroadcasterImpl(*this)), + m_manager_sp(manager_sp), + m_broadcaster_name(name) { Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT)); if (log) log->Printf ("%p Broadcaster::Broadcaster(\"%s\")", - static_cast<void*>(this), m_broadcaster_name.AsCString()); + static_cast<void*>(this), GetBroadcasterName().AsCString()); +} + +Broadcaster::BroadcasterImpl::BroadcasterImpl(Broadcaster &broadcaster) + : m_broadcaster(broadcaster), m_listeners(), m_listeners_mutex(), m_hijacking_listeners(), m_hijacking_masks() +{ } Broadcaster::~Broadcaster() @@ -47,35 +50,64 @@ Broadcaster::~Broadcaster() void Broadcaster::CheckInWithManager () { - if (m_manager != NULL) + if (m_manager_sp) { - m_manager->SignUpListenersForBroadcaster(*this); + m_manager_sp->SignUpListenersForBroadcaster(*this); } } void -Broadcaster::Clear() +Broadcaster::BroadcasterImpl::ListenerIterator (std::function <bool (const lldb::ListenerSP &listener_sp, uint32_t &event_mask)> const &callback) { - Mutex::Locker listeners_locker(m_listeners_mutex); - + // Private iterator that should be used by everyone except BroadcasterImpl::RemoveListener(). + // We have weak pointers to our listeners which means that at any point the listener can + // expire which means we will need to take it out of our list. To take care of this, we + // iterate and check that the weak pointer can be made into a valid shared pointer before + // we call the callback. If the weak pointer has expired, we remove it from our list. + collection::iterator pos = m_listeners.begin(); + while (pos != m_listeners.end()) + { + lldb::ListenerSP curr_listener_sp(pos->first.lock()); + if (curr_listener_sp) + { + if (callback(curr_listener_sp, pos->second)) + ++pos; // Keep iterating + else + return; // Done iterating + } + else + { + // The listener has been expired. Remove this entry. + pos = m_listeners.erase(pos); + } + } +} + +void +Broadcaster::BroadcasterImpl::Clear() +{ + std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex); + // Make sure the listener forgets about this broadcaster. We do // this in the broadcaster in case the broadcaster object initiates // the removal. - - collection::iterator pos, end = m_listeners.end(); - for (pos = m_listeners.begin(); pos != end; ++pos) - pos->first->BroadcasterWillDestruct (this); + + ListenerIterator([this](const lldb::ListenerSP &curr_listener_sp, uint32_t &curr_event_mask) -> bool { + curr_listener_sp->BroadcasterWillDestruct (&m_broadcaster); + return true; // Keep iterating + }); m_listeners.clear(); } -const ConstString & -Broadcaster::GetBroadcasterName () + +Broadcaster * +Broadcaster::BroadcasterImpl::GetBroadcaster() { - return m_broadcaster_name; + return &m_broadcaster; } bool -Broadcaster::GetEventNames (Stream &s, uint32_t event_mask, bool prefix_with_broadcaster_name) const +Broadcaster::BroadcasterImpl::GetEventNames (Stream &s, uint32_t event_mask, bool prefix_with_broadcaster_name) const { uint32_t num_names_added = 0; if (event_mask && !m_event_names.empty()) @@ -93,7 +125,7 @@ Broadcaster::GetEventNames (Stream &s, uint32_t event_mask, bool prefix_with_bro if (prefix_with_broadcaster_name) { - s.PutCString (m_broadcaster_name.GetCString()); + s.PutCString (GetBroadcasterName()); s.PutChar('.'); } s.PutCString(pos->second.c_str()); @@ -106,134 +138,149 @@ Broadcaster::GetEventNames (Stream &s, uint32_t event_mask, bool prefix_with_bro } void -Broadcaster::AddInitialEventsToListener (Listener *listener, uint32_t requested_events) +Broadcaster::AddInitialEventsToListener (const lldb::ListenerSP &listener_sp, uint32_t requested_events) { - } uint32_t -Broadcaster::AddListener (Listener* listener, uint32_t event_mask) +Broadcaster::BroadcasterImpl::AddListener (const lldb::ListenerSP &listener_sp, uint32_t event_mask) { - if (listener == NULL) + if (!listener_sp) return 0; - Mutex::Locker locker(m_listeners_mutex); - collection::iterator pos, end = m_listeners.end(); + std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex); - collection::iterator existing_pos = end; // See if we already have this listener, and if so, update its mask - uint32_t taken_event_types = 0; - for (pos = m_listeners.begin(); pos != end; ++pos) - { - if (pos->first == listener) - existing_pos = pos; - // For now don't descriminate on who gets what - // FIXME: Implement "unique listener for this bit" mask - // taken_event_types |= pos->second; - } - // Each event bit in a Broadcaster object can only be used - // by one listener - uint32_t available_event_types = ~taken_event_types & event_mask; + bool handled = false; - if (available_event_types) - { - // If we didn't find our listener, add it - if (existing_pos == end) - { - // Grant a new listener the available event bits - m_listeners.push_back(std::make_pair(listener, available_event_types)); - } - else + ListenerIterator([this, &listener_sp, &handled, event_mask](const lldb::ListenerSP &curr_listener_sp, uint32_t &curr_event_mask) -> bool { + if (curr_listener_sp == listener_sp) { - // Grant the existing listener the available event bits - existing_pos->second |= available_event_types; + handled = true; + curr_event_mask |= event_mask; + m_broadcaster.AddInitialEventsToListener (listener_sp, event_mask); + return false; // Stop iterating } + return true; // Keep iterating + }); + + if (!handled) + { + // Grant a new listener the available event bits + m_listeners.push_back(std::make_pair(lldb::ListenerWP(listener_sp), event_mask)); // Individual broadcasters decide whether they have outstanding data when a // listener attaches, and insert it into the listener with this method. - - AddInitialEventsToListener (listener, available_event_types); + m_broadcaster.AddInitialEventsToListener (listener_sp, event_mask); } // Return the event bits that were granted to the listener - return available_event_types; + return event_mask; } bool -Broadcaster::EventTypeHasListeners (uint32_t event_type) +Broadcaster::BroadcasterImpl::EventTypeHasListeners (uint32_t event_type) { - Mutex::Locker locker (m_listeners_mutex); - - if (m_hijacking_listeners.size() > 0 && event_type & m_hijacking_masks.back()) + std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex); + + if (!m_hijacking_listeners.empty() && event_type & m_hijacking_masks.back()) return true; if (m_listeners.empty()) return false; - collection::iterator pos, end = m_listeners.end(); - for (pos = m_listeners.begin(); pos != end; ++pos) - { - if (pos->second & event_type) - return true; - } - return false; + bool result = false; + ListenerIterator([this, event_type, &result](const lldb::ListenerSP &curr_listener_sp, uint32_t &curr_event_mask) -> bool { + + if (curr_event_mask & event_type) + { + result = true; + return false; // Stop iterating + } + else + { + return true; // Keep iterating + } + }); + return result; } bool -Broadcaster::RemoveListener (Listener* listener, uint32_t event_mask) +Broadcaster::BroadcasterImpl::RemoveListener (lldb_private::Listener *listener, uint32_t event_mask) { - Mutex::Locker locker(m_listeners_mutex); - collection::iterator pos, end = m_listeners.end(); - // See if we already have this listener, and if so, update its mask - for (pos = m_listeners.begin(); pos != end; ++pos) + if (listener) { - if (pos->first == listener) + std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex); + collection::iterator pos = m_listeners.begin(); + // See if we already have this listener, and if so, update its mask + while (pos != m_listeners.end()) { - // Relinquish all event bits in "event_mask" - pos->second &= ~event_mask; - // If all bits have been relinquished then remove this listener - if (pos->second == 0) - m_listeners.erase (pos); - return true; + lldb::ListenerSP curr_listener_sp(pos->first.lock()); + if (curr_listener_sp) + { + if (curr_listener_sp.get() == listener) + { + // Relinquish all event bits in "event_mask" + pos->second &= ~event_mask; + // If all bits have been relinquished then remove this listener + if (pos->second == 0) + m_listeners.erase (pos); + return true; + } + ++pos; + } + else + { + // The listener has been destroyed since we couldn't turn the std::weak_ptr + // into a valid shared pointer, so we can remove it. + pos = m_listeners.erase (pos); + } } } return false; } +bool +Broadcaster::BroadcasterImpl::RemoveListener (const lldb::ListenerSP &listener_sp, uint32_t event_mask) +{ + return RemoveListener (listener_sp.get(), event_mask); +} + void -Broadcaster::BroadcastEvent (EventSP &event_sp) +Broadcaster::BroadcasterImpl::BroadcastEvent (EventSP &event_sp) { return PrivateBroadcastEvent (event_sp, false); } void -Broadcaster::BroadcastEventIfUnique (EventSP &event_sp) +Broadcaster::BroadcasterImpl::BroadcastEventIfUnique (EventSP &event_sp) { return PrivateBroadcastEvent (event_sp, true); } void -Broadcaster::PrivateBroadcastEvent (EventSP &event_sp, bool unique) +Broadcaster::BroadcasterImpl::PrivateBroadcastEvent (EventSP &event_sp, bool unique) { - // Can't add a NULL event... - if (event_sp.get() == NULL) + // Can't add a nullptr event... + if (!event_sp) return; // Update the broadcaster on this event - event_sp->SetBroadcaster (this); + event_sp->SetBroadcaster (&m_broadcaster); const uint32_t event_type = event_sp->GetType(); - Mutex::Locker event_types_locker(m_listeners_mutex); + std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex); + + ListenerSP hijacking_listener_sp; - Listener *hijacking_listener = NULL; if (!m_hijacking_listeners.empty()) { assert (!m_hijacking_masks.empty()); - hijacking_listener = m_hijacking_listeners.back(); + hijacking_listener_sp = m_hijacking_listeners.back(); if ((event_type & m_hijacking_masks.back()) == 0) - hijacking_listener = NULL; + hijacking_listener_sp.reset(); } Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_EVENTS)); @@ -242,91 +289,106 @@ Broadcaster::PrivateBroadcastEvent (EventSP &event_sp, bool unique) StreamString event_description; event_sp->Dump (&event_description); log->Printf ("%p Broadcaster(\"%s\")::BroadcastEvent (event_sp = {%s}, unique =%i) hijack = %p", - static_cast<void*>(this), m_broadcaster_name.AsCString(""), + static_cast<void*>(this), GetBroadcasterName(), event_description.GetData(), unique, - static_cast<void*>(hijacking_listener)); + static_cast<void*>(hijacking_listener_sp.get())); } - if (hijacking_listener) + if (hijacking_listener_sp) { - if (unique && hijacking_listener->PeekAtNextEventForBroadcasterWithType (this, event_type)) + if (unique && hijacking_listener_sp->PeekAtNextEventForBroadcasterWithType (&m_broadcaster, event_type)) return; - hijacking_listener->AddEvent (event_sp); + hijacking_listener_sp->AddEvent (event_sp); } else { - collection::iterator pos, end = m_listeners.end(); + ListenerIterator([this, unique, event_type, &event_sp](const lldb::ListenerSP &curr_listener_sp, uint32_t &curr_event_mask) -> bool { - // Iterate through all listener/mask pairs - for (pos = m_listeners.begin(); pos != end; ++pos) - { - // If the listener's mask matches any bits that we just set, then - // put the new event on its event queue. - if (event_type & pos->second) + if (event_type & curr_event_mask) { - if (unique && pos->first->PeekAtNextEventForBroadcasterWithType (this, event_type)) - continue; - pos->first->AddEvent (event_sp); + if (!unique || curr_listener_sp->PeekAtNextEventForBroadcasterWithType (&m_broadcaster, event_type) == nullptr) + curr_listener_sp->AddEvent (event_sp); } - } + return true; // Keep iterating + }); } } void -Broadcaster::BroadcastEvent (uint32_t event_type, EventData *event_data) +Broadcaster::BroadcasterImpl::BroadcastEvent (uint32_t event_type, EventData *event_data) { EventSP event_sp (new Event (event_type, event_data)); PrivateBroadcastEvent (event_sp, false); } void -Broadcaster::BroadcastEventIfUnique (uint32_t event_type, EventData *event_data) +Broadcaster::BroadcasterImpl::BroadcastEvent (uint32_t event_type, const lldb::EventDataSP &event_data_sp) +{ + EventSP event_sp (new Event (event_type, event_data_sp)); + PrivateBroadcastEvent (event_sp, false); +} + +void +Broadcaster::BroadcasterImpl::BroadcastEventIfUnique (uint32_t event_type, EventData *event_data) { EventSP event_sp (new Event (event_type, event_data)); PrivateBroadcastEvent (event_sp, true); } bool -Broadcaster::HijackBroadcaster (Listener *listener, uint32_t event_mask) +Broadcaster::BroadcasterImpl::HijackBroadcaster (const lldb::ListenerSP &listener_sp, uint32_t event_mask) { - Mutex::Locker event_types_locker(m_listeners_mutex); + std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex); Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_EVENTS)); if (log) log->Printf ("%p Broadcaster(\"%s\")::HijackBroadcaster (listener(\"%s\")=%p)", - static_cast<void*>(this), m_broadcaster_name.AsCString(""), - listener->m_name.c_str(), static_cast<void*>(listener)); - m_hijacking_listeners.push_back(listener); + static_cast<void*>(this), GetBroadcasterName(), + listener_sp->m_name.c_str(), static_cast<void*>(listener_sp.get())); + m_hijacking_listeners.push_back(listener_sp); m_hijacking_masks.push_back(event_mask); return true; } bool -Broadcaster::IsHijackedForEvent (uint32_t event_mask) +Broadcaster::BroadcasterImpl::IsHijackedForEvent (uint32_t event_mask) { - Mutex::Locker event_types_locker(m_listeners_mutex); + std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex); if (!m_hijacking_listeners.empty()) return (event_mask & m_hijacking_masks.back()) != 0; return false; } +const char * +Broadcaster::BroadcasterImpl::GetHijackingListenerName() +{ + if (m_hijacking_listeners.size()) + { + return m_hijacking_listeners.back()->GetName(); + } + else + { + return nullptr; + } +} + void -Broadcaster::RestoreBroadcaster () +Broadcaster::BroadcasterImpl::RestoreBroadcaster () { - Mutex::Locker event_types_locker(m_listeners_mutex); + std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex); if (!m_hijacking_listeners.empty()) { Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_EVENTS)); if (log) { - Listener *listener = m_hijacking_listeners.back(); + ListenerSP listener_sp = m_hijacking_listeners.back(); log->Printf ("%p Broadcaster(\"%s\")::RestoreBroadcaster (about to pop listener(\"%s\")=%p)", static_cast<void*>(this), - m_broadcaster_name.AsCString(""), - listener->m_name.c_str(), static_cast<void*>(listener)); + GetBroadcasterName(), + listener_sp->m_name.c_str(), static_cast<void*>(listener_sp.get())); } m_hijacking_listeners.pop_back(); } @@ -341,11 +403,7 @@ Broadcaster::GetBroadcasterClass() const return class_name; } -BroadcastEventSpec::BroadcastEventSpec (const BroadcastEventSpec &rhs) : - m_broadcaster_class (rhs.m_broadcaster_class), - m_event_bits (rhs.m_event_bits) -{ -} +BroadcastEventSpec::BroadcastEventSpec(const BroadcastEventSpec &rhs) = default; bool BroadcastEventSpec::operator< (const BroadcastEventSpec &rhs) const @@ -360,25 +418,24 @@ BroadcastEventSpec::operator< (const BroadcastEventSpec &rhs) const } } -const BroadcastEventSpec & -BroadcastEventSpec::operator= (const BroadcastEventSpec &rhs) +BroadcastEventSpec & +BroadcastEventSpec::operator=(const BroadcastEventSpec &rhs) = default; + +BroadcasterManager::BroadcasterManager() : m_manager_mutex() { - m_broadcaster_class = rhs.m_broadcaster_class; - m_event_bits = rhs.m_event_bits; - return *this; } -BroadcasterManager::BroadcasterManager() : - m_manager_mutex(Mutex::eMutexTypeRecursive) +lldb::BroadcasterManagerSP +BroadcasterManager::MakeBroadcasterManager() { - + return BroadcasterManagerSP(new BroadcasterManager()); } uint32_t -BroadcasterManager::RegisterListenerForEvents (Listener &listener, BroadcastEventSpec event_spec) +BroadcasterManager::RegisterListenerForEvents (const lldb::ListenerSP &listener_sp, BroadcastEventSpec event_spec) { - Mutex::Locker locker(m_manager_mutex); - + std::lock_guard<std::recursive_mutex> guard(m_manager_mutex); + collection::iterator iter = m_event_map.begin(), end_iter = m_event_map.end(); uint32_t available_bits = event_spec.GetEventBits(); @@ -391,28 +448,28 @@ BroadcasterManager::RegisterListenerForEvents (Listener &listener, BroadcastEven if (available_bits != 0) { - m_event_map.insert (event_listener_key (BroadcastEventSpec (event_spec.GetBroadcasterClass(), available_bits), &listener)); - m_listeners.insert(&listener); + m_event_map.insert (event_listener_key (BroadcastEventSpec (event_spec.GetBroadcasterClass(), available_bits), listener_sp)); + m_listeners.insert(listener_sp); } return available_bits; } bool -BroadcasterManager::UnregisterListenerForEvents (Listener &listener, BroadcastEventSpec event_spec) +BroadcasterManager::UnregisterListenerForEvents (const lldb::ListenerSP &listener_sp, BroadcastEventSpec event_spec) { - Mutex::Locker locker(m_manager_mutex); + std::lock_guard<std::recursive_mutex> guard(m_manager_mutex); bool removed_some = false; - if (m_listeners.erase(&listener) == 0) + if (m_listeners.erase(listener_sp) == 0) return false; - ListenerMatchesAndSharedBits predicate (event_spec, listener); + ListenerMatchesAndSharedBits predicate (event_spec, listener_sp); std::vector<BroadcastEventSpec> to_be_readded; uint32_t event_bits_to_remove = event_spec.GetEventBits(); // Go through the map and delete the exact matches, and build a list of matches that weren't exact to re-add: - while (1) + while (true) { collection::iterator iter, end_iter = m_event_map.end(); iter = find_if (m_event_map.begin(), end_iter, predicate); @@ -437,36 +494,57 @@ BroadcasterManager::UnregisterListenerForEvents (Listener &listener, BroadcastEv // Okay now add back the bits that weren't completely removed: for (size_t i = 0; i < to_be_readded.size(); i++) { - m_event_map.insert (event_listener_key (to_be_readded[i], &listener)); + m_event_map.insert (event_listener_key (to_be_readded[i], listener_sp)); } return removed_some; } -Listener * +ListenerSP BroadcasterManager::GetListenerForEventSpec (BroadcastEventSpec event_spec) const { - Mutex::Locker locker(*(const_cast<Mutex *> (&m_manager_mutex))); - + std::lock_guard<std::recursive_mutex> guard(m_manager_mutex); + collection::const_iterator iter, end_iter = m_event_map.end(); iter = find_if (m_event_map.begin(), end_iter, BroadcastEventSpecMatches (event_spec)); if (iter != end_iter) return (*iter).second; else - return NULL; + return nullptr; } void -BroadcasterManager::RemoveListener (Listener &listener) +BroadcasterManager::RemoveListener(Listener *listener) { - Mutex::Locker locker(m_manager_mutex); - ListenerMatches predicate (listener); + std::lock_guard<std::recursive_mutex> guard(m_manager_mutex); + ListenerMatchesPointer predicate (listener); + listener_collection::iterator iter = m_listeners.begin(), end_iter = m_listeners.end(); + + std::find_if (iter, end_iter, predicate); + if (iter != end_iter) + m_listeners.erase(iter); + + while (true) + { + collection::iterator iter, end_iter = m_event_map.end(); + iter = find_if (m_event_map.begin(), end_iter, predicate); + if (iter == end_iter) + break; + else + m_event_map.erase(iter); + } +} +void +BroadcasterManager::RemoveListener (const lldb::ListenerSP &listener_sp) +{ + std::lock_guard<std::recursive_mutex> guard(m_manager_mutex); + ListenerMatches predicate (listener_sp); - if (m_listeners.erase (&listener) == 0) + if (m_listeners.erase (listener_sp) == 0) return; - while (1) + while (true) { collection::iterator iter, end_iter = m_event_map.end(); iter = find_if (m_event_map.begin(), end_iter, predicate); @@ -480,8 +558,8 @@ BroadcasterManager::RemoveListener (Listener &listener) void BroadcasterManager::SignUpListenersForBroadcaster (Broadcaster &broadcaster) { - Mutex::Locker locker(m_manager_mutex); - + std::lock_guard<std::recursive_mutex> guard(m_manager_mutex); + collection::iterator iter = m_event_map.begin(), end_iter = m_event_map.end(); while (iter != end_iter @@ -495,12 +573,11 @@ BroadcasterManager::SignUpListenersForBroadcaster (Broadcaster &broadcaster) void BroadcasterManager::Clear () { - Mutex::Locker locker(m_manager_mutex); + std::lock_guard<std::recursive_mutex> guard(m_manager_mutex); listener_collection::iterator end_iter = m_listeners.end(); for (listener_collection::iterator iter = m_listeners.begin(); iter != end_iter; iter++) - (*iter)->BroadcasterManagerWillDestruct(this); + (*iter)->BroadcasterManagerWillDestruct(this->shared_from_this()); m_listeners.clear(); m_event_map.clear(); - } |