replica
/
hanchenye-llvm-project
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Use the multi-lockable form of std::lock for operator= 

For = operators for lists that have mutexes, we were either
just taking the locks sequentially or hand-rolling a trick
to try to avoid lock inversion.  Use the std::lock mechanism
for this instead.

Differential Revision: https://reviews.llvm.org/D59957

llvm-svn: 357276
This commit is contained in:
Jim Ingham 2019-03-29 17:07:30 +00:00
parent dd0c7d88c6
commit cdd4892f12
6 changed files with 25 additions and 36 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
lldb/include/lldb/Core/ModuleSpec.h
View File

@ -311,8 +311,10 @@ public:
ModuleSpecList &operator=(const ModuleSpecList &rhs) {
if (this != &rhs) {
std::lock_guard<std::recursive_mutex> lhs_guard(m_mutex);
std::lock_guard<std::recursive_mutex> rhs_guard(rhs.m_mutex);
std::lock(m_mutex, rhs.m_mutex);
std::lock_guard<std::recursive_mutex> lhs_guard(m_mutex, std::adopt_lock);
std::lock_guard<std::recursive_mutex> rhs_guard(rhs.m_mutex,
std::adopt_lock);
m_specs = rhs.m_specs;
}
return *this;

7
lldb/include/lldb/Utility/StreamTee.h
View File

@ -49,8 +49,11 @@ public:
StreamTee &operator=(const StreamTee &rhs) {
if (this != &rhs) {
Stream::operator=(rhs);
std::lock_guard<std::recursive_mutex> lhs_locker(m_streams_mutex);
std::lock_guard<std::recursive_mutex> rhs_locker(rhs.m_streams_mutex);
std::lock(m_streams_mutex, rhs.m_streams_mutex);
std::lock_guard<std::recursive_mutex> lhs_locker(m_streams_mutex,
std::adopt_lock);
std::lock_guard<std::recursive_mutex> rhs_locker(rhs.m_streams_mutex,
std::adopt_lock);
m_streams = rhs.m_streams;
}
return *this;

12
lldb/source/Breakpoint/BreakpointLocationCollection.cpp
View File

@ -181,17 +181,11 @@ void BreakpointLocationCollection::GetDescription(
BreakpointLocationCollection &BreakpointLocationCollection::operator=(
const BreakpointLocationCollection &rhs) {
// Same trick as in ModuleList to avoid lock inversion.
if (this != &rhs) {
if (uintptr_t(this) > uintptr_t(&rhs)) {
std::lock_guard<std::mutex> lhs_guard(m_collection_mutex);
std::lock_guard<std::mutex> rhs_guard(rhs.m_collection_mutex);
std::lock(m_collection_mutex, rhs.m_collection_mutex);
std::lock_guard<std::mutex> lhs_guard(m_collection_mutex, std::adopt_lock);
std::lock_guard<std::mutex> rhs_guard(rhs.m_collection_mutex, std::adopt_lock);
m_break_loc_collection = rhs.m_break_loc_collection;
} else {
std::lock_guard<std::mutex> lhs_guard(m_collection_mutex);
std::lock_guard<std::mutex> rhs_guard(rhs.m_collection_mutex);
m_break_loc_collection = rhs.m_break_loc_collection;
}
}
return *this;
}

25
lldb/source/Core/ModuleList.cpp
View File

@ -130,25 +130,12 @@ ModuleList::ModuleList(ModuleList::Notifier *notifier)
const ModuleList &ModuleList::operator=(const ModuleList &rhs) {
if (this != &rhs) {
// That's probably me nit-picking, but in theoretical situation:
//
// * that two threads A B and
// * two ModuleList's x y do opposite assignments ie.:
//
// in thread A: | in thread B:
// x = y; | y = x;
//
// This establishes correct(same) lock taking order and thus avoids
// priority inversion.
if (uintptr_t(this) > uintptr_t(&rhs)) {
std::lock_guard<std::recursive_mutex> lhs_guard(m_modules_mutex);
std::lock_guard<std::recursive_mutex> rhs_guard(rhs.m_modules_mutex);
m_modules = rhs.m_modules;
} else {
std::lock_guard<std::recursive_mutex> lhs_guard(m_modules_mutex);
std::lock_guard<std::recursive_mutex> rhs_guard(rhs.m_modules_mutex);
m_modules = rhs.m_modules;
}
std::lock(m_modules_mutex, rhs.m_modules_mutex);
std::lock_guard<std::recursive_mutex> lhs_guard(m_modules_mutex,
std::adopt_lock);
std::lock_guard<std::recursive_mutex> rhs_guard(rhs.m_modules_mutex,
std::adopt_lock);
m_modules = rhs.m_modules;
}
return *this;
}

5
lldb/source/Target/SectionLoadList.cpp
View File

@ -27,8 +27,9 @@ SectionLoadList::SectionLoadList(const SectionLoadList &rhs)
}
void SectionLoadList::operator=(const SectionLoadList &rhs) {
std::lock_guard<std::recursive_mutex> lhs_guard(m_mutex);
std::lock_guard<std::recursive_mutex> rhs_guard(rhs.m_mutex);
std::lock(m_mutex, rhs.m_mutex);
std::lock_guard<std::recursive_mutex> lhs_guard(m_mutex, std::adopt_lock);
std::lock_guard<std::recursive_mutex> rhs_guard(rhs.m_mutex, std::adopt_lock);
m_addr_to_sect = rhs.m_addr_to_sect;
m_sect_to_addr = rhs.m_sect_to_addr;
}

6
lldb/source/Target/ThreadList.cpp
View File

@ -37,8 +37,10 @@ const ThreadList &ThreadList::operator=(const ThreadList &rhs) {
if (this != &rhs) {
// Lock both mutexes to make sure neither side changes anyone on us while
// the assignment occurs
std::lock_guard<std::recursive_mutex> guard(GetMutex());
std::lock_guard<std::recursive_mutex> rhs_guard(rhs.GetMutex());
std::lock(GetMutex(), rhs.GetMutex());
std::lock_guard<std::recursive_mutex> guard(GetMutex(), std::adopt_lock);
std::lock_guard<std::recursive_mutex> rhs_guard(rhs.GetMutex(),
std::adopt_lock);
m_process = rhs.m_process;
m_stop_id = rhs.m_stop_id;