From 81bc750723a18f21cd17d1b173cd2a4dda9cea6e Mon Sep 17 00:00:00 2001 From: Ben Murdoch Date: Tue, 24 May 2011 11:24:40 +0100 Subject: Merge WebKit at r80534: Intial merge by Git Change-Id: Ia7a83357124c9e1cdb1debf55d9661ec0bd09a61 --- Source/JavaScriptCore/runtime/WeakGCMap.h | 187 ++++++++++++++++-------------- 1 file changed, 102 insertions(+), 85 deletions(-) (limited to 'Source/JavaScriptCore/runtime/WeakGCMap.h') diff --git a/Source/JavaScriptCore/runtime/WeakGCMap.h b/Source/JavaScriptCore/runtime/WeakGCMap.h index 7bf4503..a40e684 100644 --- a/Source/JavaScriptCore/runtime/WeakGCMap.h +++ b/Source/JavaScriptCore/runtime/WeakGCMap.h @@ -26,110 +26,127 @@ #ifndef WeakGCMap_h #define WeakGCMap_h -#include "Heap.h" +#include "Handle.h" +#include "JSGlobalData.h" #include namespace JSC { -class JSCell; - -// A HashMap whose get() function returns emptyValue() for cells awaiting destruction. -template -class WeakGCMap { +// A HashMap for GC'd values that removes entries when the associated value +// dies. +template class WeakGCMap : private Finalizer { WTF_MAKE_FAST_ALLOCATED; - /* - Invariants: - * A value enters the WeakGCMap marked. (Guaranteed by set().) - * A value that becomes unmarked leaves the WeakGCMap before being recycled. (Guaranteed by the value's destructor removing it from the WeakGCMap.) - * A value that becomes unmarked leaves the WeakGCMap before becoming marked again. (Guaranteed by all destructors running before the mark phase begins.) - * During the mark phase, all values in the WeakGCMap are valid. (Guaranteed by all destructors running before the mark phase begins.) - */ + WTF_MAKE_NONCOPYABLE(WeakGCMap); + + typedef HashMap MapType; + typedef typename HandleTypes::ExternalType ExternalType; + typedef typename MapType::iterator map_iterator; public: - typedef typename HashMap >::iterator iterator; - typedef typename HashMap >::const_iterator const_iterator; - + + struct iterator { + iterator(map_iterator iter) + : m_iterator(iter) + { + } + + std::pair get() const { return std::make_pair(m_iterator->first, HandleTypes::getFromSlot(m_iterator->second)); } + std::pair getSlot() const { return *m_iterator; } + + iterator& operator++() { ++m_iterator; return *this; } + + // postfix ++ intentionally omitted + + // Comparison. + bool operator==(const iterator& other) const { return m_iterator == other.m_iterator; } + bool operator!=(const iterator& other) const { return m_iterator != other.m_iterator; } + + private: + map_iterator m_iterator; + }; + + WeakGCMap() + { + } + bool isEmpty() { return m_map.isEmpty(); } - void clear() { m_map.clear(); } + void clear() + { + map_iterator end = m_map.end(); + for (map_iterator ptr = m_map.begin(); ptr != end; ++ptr) + HandleHeap::heapFor(ptr->second)->deallocate(ptr->second); + m_map.clear(); + } - MappedType* get(const KeyType&) const; - pair set(const KeyType&, MappedType*); - MappedType* take(const KeyType&); + ExternalType get(const KeyType& key) const + { + return HandleTypes::getFromSlot(m_map.get(key)); + } - // These unchecked functions provide access to a value even if the value's - // mark bit is not set. This is used, among other things, to retrieve values - // during the GC mark phase, which begins by clearing all mark bits. - - size_t uncheckedSize() { return m_map.size(); } + HandleSlot getSlot(const KeyType& key) const + { + return m_map.get(key); + } - MappedType* uncheckedGet(const KeyType& key) const { return m_map.get(key).get(); } - DeprecatedPtr* uncheckedGetSlot(const KeyType& key) + void set(JSGlobalData& globalData, const KeyType& key, ExternalType value) { - iterator iter = m_map.find(key); - if (iter == m_map.end()) - return 0; - return &iter->second; + pair iter = m_map.add(key, 0); + HandleSlot slot = iter.first->second; + if (iter.second) { + slot = globalData.allocateGlobalHandle(); + iter.first->second = slot; + HandleHeap::heapFor(slot)->makeWeak(slot, this, key); + } + HandleHeap::heapFor(slot)->writeBarrier(slot, value); + *slot = value; } - bool uncheckedRemove(const KeyType&, MappedType*); - iterator uncheckedBegin() { return m_map.begin(); } - iterator uncheckedEnd() { return m_map.end(); } + ExternalType take(const KeyType& key) + { + HandleSlot slot = m_map.take(key); + if (!slot) + return HashTraits::emptyValue(); + ExternalType result = HandleTypes::getFromSlot(slot); + HandleHeap::heapFor(slot)->deallocate(slot); + return result; + } - const_iterator uncheckedBegin() const { return m_map.begin(); } - const_iterator uncheckedEnd() const { return m_map.end(); } + size_t size() { return m_map.size(); } - bool isValid(iterator it) const { return Heap::isMarked(it->second.get()); } - bool isValid(const_iterator it) const { return Heap::isMarked(it->second.get()); } + bool deprecatedRemove(const KeyType& key, ExternalType value) + { + // This only exists in order to allow some semblance of correctness to + // the JSWeakObjectMapClear API + typename MapType::iterator iter = m_map.find(key); + if (iter == m_map.end()) + return false; + HandleSlot slot = iter->second; + ExternalType inmap = HandleTypes::getFromSlot(slot); + if (inmap && inmap != value) + return false; + m_map.remove(iter); + HandleHeap::heapFor(slot)->deallocate(slot); + return true; + } + iterator begin() { return iterator(m_map.begin()); } + iterator end() { return iterator(m_map.end()); } + + ~WeakGCMap() + { + clear(); + } + private: - HashMap > m_map; -}; - -template -inline MappedType* WeakGCMap::get(const KeyType& key) const -{ - MappedType* result = m_map.get(key).get(); - if (result == HashTraits::emptyValue()) - return result; - if (!Heap::isMarked(result)) - return HashTraits::emptyValue(); - return result; -} - -template -MappedType* WeakGCMap::take(const KeyType& key) -{ - MappedType* result = m_map.take(key).get(); - if (result == HashTraits::emptyValue()) - return result; - if (!Heap::isMarked(result)) - return HashTraits::emptyValue(); - return result; -} - -template -pair::iterator, bool> WeakGCMap::set(const KeyType& key, MappedType* value) -{ - Heap::setMarked(value); // If value is newly allocated, it's not marked, so mark it now. - pair result = m_map.add(key, value); - if (!result.second) { // pre-existing entry - result.second = !Heap::isMarked(result.first->second.get()); - result.first->second = value; + virtual void finalize(Handle, void* key) + { + HandleSlot slot = m_map.take(static_cast(key)); + ASSERT(slot); + HandleHeap::heapFor(slot)->deallocate(slot); } - return result; -} - -template -bool WeakGCMap::uncheckedRemove(const KeyType& key, MappedType* value) -{ - iterator it = m_map.find(key); - if (it == m_map.end()) - return false; - if (it->second.get() != value) - return false; - m_map.remove(it); - return true; -} + + MapType m_map; +}; } // namespace JSC -- cgit v1.1