From c34ebf65af0139eaf5cb0969fabcd32c0b6e1710 Mon Sep 17 00:00:00 2001 From: Owen Anderson Date: Wed, 19 Aug 2009 17:07:46 +0000 Subject: [PATCH] Reapply my less-lock-contention-in-leak-detector patch, now with new files actually added. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@79429 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/Support/LeakDetector.h | 6 +- lib/VMCore/LLVMContextImpl.h | 5 ++ lib/VMCore/LeakDetector.cpp | 114 ++++++---------------------- lib/VMCore/LeaksContext.h | 90 ++++++++++++++++++++++ 4 files changed, 122 insertions(+), 93 deletions(-) create mode 100644 lib/VMCore/LeaksContext.h diff --git a/include/llvm/Support/LeakDetector.h b/include/llvm/Support/LeakDetector.h index 8d74ac663b1..7dbfdbf3d52 100644 --- a/include/llvm/Support/LeakDetector.h +++ b/include/llvm/Support/LeakDetector.h @@ -56,9 +56,9 @@ struct LeakDetector { /// The specified message will be printed indicating when the check was /// performed. /// - static void checkForGarbage(const std::string &Message) { + static void checkForGarbage(LLVMContext &C, const std::string &Message) { #ifndef NDEBUG - checkForGarbageImpl(Message); + checkForGarbageImpl(C, Message); #endif } @@ -83,7 +83,7 @@ private: static void removeGarbageObjectImpl(const Value *Object); static void addGarbageObjectImpl(void *Object); static void removeGarbageObjectImpl(void *Object); - static void checkForGarbageImpl(const std::string &Message); + static void checkForGarbageImpl(LLVMContext &C, const std::string &Message); }; } // End llvm namespace diff --git a/lib/VMCore/LLVMContextImpl.h b/lib/VMCore/LLVMContextImpl.h index aaa48ca0d4f..20d410eaf87 100644 --- a/lib/VMCore/LLVMContextImpl.h +++ b/lib/VMCore/LLVMContextImpl.h @@ -16,6 +16,7 @@ #define LLVM_LLVMCONTEXT_IMPL_H #include "ConstantsContext.h" +#include "LeaksContext.h" #include "TypesContext.h" #include "llvm/LLVMContext.h" #include "llvm/Constants.h" @@ -134,6 +135,10 @@ public: ConstantInt *TheTrueVal; ConstantInt *TheFalseVal; + // Lock used for guarding access to the leak detector + sys::SmartMutex LLVMObjectsLock; + LeakDetectorImpl LLVMObjects; + // Lock used for guarding access to the type maps. sys::SmartMutex TypeMapLock; diff --git a/lib/VMCore/LeakDetector.cpp b/lib/VMCore/LeakDetector.cpp index a6be1afed49..31857421746 100644 --- a/lib/VMCore/LeakDetector.cpp +++ b/lib/VMCore/LeakDetector.cpp @@ -11,129 +11,63 @@ // //===----------------------------------------------------------------------===// +#include "LLVMContextImpl.h" #include "llvm/Support/LeakDetector.h" #include "llvm/ADT/SmallPtrSet.h" #include "llvm/Support/Compiler.h" #include "llvm/Support/ManagedStatic.h" #include "llvm/Support/Streams.h" -#include "llvm/System/RWMutex.h" +#include "llvm/System/Mutex.h" #include "llvm/System/Threading.h" #include "llvm/Value.h" using namespace llvm; -namespace { - template - struct VISIBILITY_HIDDEN PrinterTrait { - static void print(const T* P) { cerr << P; } - }; +static ManagedStatic > ObjectsLock; +static ManagedStatic > Objects; - template<> - struct VISIBILITY_HIDDEN PrinterTrait { - static void print(const Value* P) { cerr << *P; } - }; - - ManagedStatic > LeakDetectorLock; - - template - struct VISIBILITY_HIDDEN LeakDetectorImpl { - explicit LeakDetectorImpl(const char* const name = "") : - Cache(0), Name(name) { } - - void clear() { - Cache = 0; - Ts.clear(); - } - - void setName(const char* n) { - Name = n; - } - - // Because the most common usage pattern, by far, is to add a - // garbage object, then remove it immediately, we optimize this - // case. When an object is added, it is not added to the set - // immediately, it is added to the CachedValue Value. If it is - // immediately removed, no set search need be performed. - void addGarbage(const T* o) { - sys::SmartScopedWriter Writer(*LeakDetectorLock); - if (Cache) { - assert(Ts.count(Cache) == 0 && "Object already in set!"); - Ts.insert(Cache); - } - Cache = o; - } - - void removeGarbage(const T* o) { - sys::SmartScopedWriter Writer(*LeakDetectorLock); - if (o == Cache) - Cache = 0; // Cache hit - else - Ts.erase(o); - } - - bool hasGarbage(const std::string& Message) { - addGarbage(0); // Flush the Cache - - sys::SmartScopedReader Reader(*LeakDetectorLock); - assert(Cache == 0 && "No value should be cached anymore!"); - - if (!Ts.empty()) { - cerr << "Leaked " << Name << " objects found: " << Message << ":\n"; - for (typename SmallPtrSet::iterator I = Ts.begin(), - E = Ts.end(); I != E; ++I) { - cerr << "\t"; - PrinterTrait::print(*I); - cerr << "\n"; - } - cerr << '\n'; - - return true; - } - - return false; - } - - private: - SmallPtrSet Ts; - const T* Cache; - const char* Name; - }; - - static ManagedStatic > Objects; - static ManagedStatic > LLVMObjects; - - static void clearGarbage() { - Objects->clear(); - LLVMObjects->clear(); - } +static void clearGarbage(LLVMContext &Context) { + Objects->clear(); + Context.pImpl->LLVMObjects.clear(); } void LeakDetector::addGarbageObjectImpl(void *Object) { + sys::SmartScopedLock Lock(*ObjectsLock); Objects->addGarbage(Object); } void LeakDetector::addGarbageObjectImpl(const Value *Object) { - LLVMObjects->addGarbage(Object); + LLVMContextImpl *pImpl = Object->getContext().pImpl; + sys::SmartScopedLock Lock(pImpl->LLVMObjectsLock); + pImpl->LLVMObjects.addGarbage(Object); } void LeakDetector::removeGarbageObjectImpl(void *Object) { + sys::SmartScopedLock Lock(*ObjectsLock); Objects->removeGarbage(Object); } void LeakDetector::removeGarbageObjectImpl(const Value *Object) { - LLVMObjects->removeGarbage(Object); + LLVMContextImpl *pImpl = Object->getContext().pImpl; + sys::SmartScopedLock Lock(pImpl->LLVMObjectsLock); + pImpl->LLVMObjects.removeGarbage(Object); } -void LeakDetector::checkForGarbageImpl(const std::string &Message) { +void LeakDetector::checkForGarbageImpl(LLVMContext &Context, + const std::string &Message) { + LLVMContextImpl *pImpl = Context.pImpl; + sys::SmartScopedLock Lock(*ObjectsLock); + sys::SmartScopedLock CLock(pImpl->LLVMObjectsLock); + Objects->setName("GENERIC"); - LLVMObjects->setName("LLVM"); + pImpl->LLVMObjects.setName("LLVM"); // use non-short-circuit version so that both checks are performed if (Objects->hasGarbage(Message) | - LLVMObjects->hasGarbage(Message)) + pImpl->LLVMObjects.hasGarbage(Message)) cerr << "\nThis is probably because you removed an object, but didn't " << "delete it. Please check your code for memory leaks.\n"; // Clear out results so we don't get duplicate warnings on // next call... - clearGarbage(); + clearGarbage(Context); } diff --git a/lib/VMCore/LeaksContext.h b/lib/VMCore/LeaksContext.h new file mode 100644 index 00000000000..4c45b86b5ff --- /dev/null +++ b/lib/VMCore/LeaksContext.h @@ -0,0 +1,90 @@ +//===---------------- ----LeaksContext.h - Implementation ------*- C++ -*--===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This file defines various helper methods and classes used by +// LLVMContextImpl for leaks detectors. +// +//===----------------------------------------------------------------------===// + +#include "llvm/Value.h" +#include "llvm/Support/Streams.h" +#include "llvm/ADT/SmallPtrSet.h" + +using namespace llvm; + +template +struct PrinterTrait { + static void print(const T* P) { cerr << P; } +}; + +template<> +struct PrinterTrait { + static void print(const Value* P) { cerr << *P; } +}; + +template +struct LeakDetectorImpl { + explicit LeakDetectorImpl(const char* const name = "") : + Cache(0), Name(name) { } + + void clear() { + Cache = 0; + Ts.clear(); + } + + void setName(const char* n) { + Name = n; + } + + // Because the most common usage pattern, by far, is to add a + // garbage object, then remove it immediately, we optimize this + // case. When an object is added, it is not added to the set + // immediately, it is added to the CachedValue Value. If it is + // immediately removed, no set search need be performed. + void addGarbage(const T* o) { + if (Cache) { + assert(Ts.count(Cache) == 0 && "Object already in set!"); + Ts.insert(Cache); + } + Cache = o; + } + + void removeGarbage(const T* o) { + if (o == Cache) + Cache = 0; // Cache hit + else + Ts.erase(o); + } + + bool hasGarbage(const std::string& Message) { + addGarbage(0); // Flush the Cache + + assert(Cache == 0 && "No value should be cached anymore!"); + + if (!Ts.empty()) { + cerr << "Leaked " << Name << " objects found: " << Message << ":\n"; + for (typename SmallPtrSet::iterator I = Ts.begin(), + E = Ts.end(); I != E; ++I) { + cerr << "\t"; + PrinterTrait::print(*I); + cerr << "\n"; + } + cerr << '\n'; + + return true; + } + + return false; + } + +private: + SmallPtrSet Ts; + const T* Cache; + const char* Name; +}; -- 2.34.1