• ggaren@apple.com's avatar
    JavaScriptCore: Changed GC from mark-sweep to mark-allocate. · 6a429819
    ggaren@apple.com authored
            
    Reviewed by Sam Weinig.
    
    Added WeakGCMap to keep WebCore blissfully ignorant about objects that
    have become garbage but haven't run their destructors yet.
            
    1% SunSpider speedup.
    7.6% v8 speedup (37% splay speedup).
    17% speedup on bench-alloc-nonretained.js.
    18% speedup on bench-alloc-retained.js.
    
    * API/JSBase.cpp:
    (JSGarbageCollect):
    * API/JSContextRef.cpp:
    * JavaScriptCore.exp:
    * JavaScriptCore.xcodeproj/project.pbxproj: Updated for renames and new
    files.
    
    * debugger/Debugger.cpp:
    (JSC::Debugger::recompileAllJSFunctions): Updated to use the Collector
    iterator abstraction.
    
    * jsc.cpp:
    (functionGC): Updated for rename.
    
    * runtime/Collector.cpp: Slightly reduced the number of allocations per
    collection, so that small workloads only allocate on collector block,
    rather than two.
    
    (JSC::Heap::Heap): Updated to use the new allocateBlock function.
    
    (JSC::Heap::destroy): Updated to use the new freeBlocks function.
    
    (JSC::Heap::allocateBlock): New function to initialize a block when
    allocating it.
    
    (JSC::Heap::freeBlock): Consolidated the responsibility for running
    destructors into this function.
    
    (JSC::Heap::freeBlocks): Updated to use freeBlock.
    
    (JSC::Heap::recordExtraCost): Sweep the heap in this reporting function,
    so that allocation, which is more common, doesn't have to check extraCost.
    
    (JSC::Heap::heapAllocate): Run destructors right before recycling a
    garbage cell. This has better cache utilization than a separate sweep phase.
    
    (JSC::Heap::resizeBlocks):
    (JSC::Heap::growBlocks):
    (JSC::Heap::shrinkBlocks): New set of functions for managing the size of
    the heap, now that the heap doesn't maintain any information about its
    size.
    
    (JSC::isPointerAligned):
    (JSC::isHalfCellAligned):
    (JSC::isPossibleCell):
    (JSC::isCellAligned):
    (JSC::Heap::markConservatively): Cleaned up this code a bit.
    
    (JSC::Heap::clearMarkBits):
    (JSC::Heap::markedCells): Some helper functions for examining the the mark
    bitmap.
    
    (JSC::Heap::sweep): Simplified this function by using a DeadObjectIterator.
    
    (JSC::Heap::markRoots): Reordered some operations for clarity.
    
    (JSC::Heap::objectCount):
    (JSC::Heap::addToStatistics):
    (JSC::Heap::statistics): Rewrote these functions to calculate an object
    count on demand, since the heap doesn't maintain this information by 
    itself.
    
    (JSC::Heap::reset): New function for resetting the heap once we've
    exhausted heap space.
    
    (JSC::Heap::collectAllGarbage): This function matches the old collect()
    behavior, but it's now an uncommon function used only by API.
    
    * runtime/Collector.h:
    (JSC::CollectorBitmap::count):
    (JSC::CollectorBitmap::isEmpty): Added some helper functions for managing
    the collector mark bitmap.
    
    (JSC::Heap::reportExtraMemoryCost): Changed reporting from cell equivalents
    to bytes, so it's easier to understand.
            
    * runtime/CollectorHeapIterator.h:
    (JSC::CollectorHeapIterator::CollectorHeapIterator):
    (JSC::CollectorHeapIterator::operator!=):
    (JSC::CollectorHeapIterator::operator*):
    (JSC::CollectorHeapIterator::advance):
    (JSC::::LiveObjectIterator):
    (JSC::::operator):
    (JSC::::DeadObjectIterator):
    (JSC::::ObjectIterator): New iterators for encapsulating details about
    heap layout, and what's live and dead on the heap.
    
    * runtime/JSArray.cpp:
    (JSC::JSArray::putSlowCase):
    (JSC::JSArray::increaseVectorLength): Delay reporting extra cost until
    we're fully constructed, so the heap mark phase won't visit us in an
    invalid state.
    
    * runtime/JSCell.h:
    (JSC::JSCell::):
    (JSC::JSCell::createDummyStructure):
    (JSC::JSCell::JSCell):
    * runtime/JSGlobalData.cpp:
    (JSC::JSGlobalData::JSGlobalData):
    * runtime/JSGlobalData.h: Added a dummy cell to simplify allocation logic.
    
    * runtime/JSString.h:
    (JSC::jsSubstring): Don't report extra cost for substrings, since they
    share a buffer that's already reported extra cost.
    
    * runtime/Tracing.d:
    * runtime/Tracing.h: Changed these dtrace hooks not to report object
    counts, since they're no longer cheap to compute.
    
    * runtime/UString.h: Updated for renames.
    
    * runtime/WeakGCMap.h: Added.
    (JSC::WeakGCMap::isEmpty):
    (JSC::WeakGCMap::uncheckedGet):
    (JSC::WeakGCMap::uncheckedBegin):
    (JSC::WeakGCMap::uncheckedEnd):
    (JSC::::get):
    (JSC::::take):
    (JSC::::set):
    (JSC::::uncheckedRemove): Mentioned above.
    
    * wtf/StdLibExtras.h:
    (WTF::bitCount): Added a bit population count function, so the heap can
    count live objects to fulfill statistics questions.
    
    JavaScriptGlue: Changed GC from mark-sweep to mark-allocate.
            
    Reviewed by Sam Weinig.
    
    * JavaScriptGlue.cpp:
    (JSCollect): Updated for rename. Fixed a bug where JSGlue would not check
    to avoid nested GC calls.
    
    WebCore: Changed GC from mark-sweep to mark-allocate.
    
    Reviewed by Sam Weinig.
    
    * ForwardingHeaders/runtime/WeakGCMap.h: Added.
    * bindings/js/GCController.cpp:
    (WebCore::collect):
    (WebCore::GCController::gcTimerFired):
    (WebCore::GCController::garbageCollectNow): Updated for rename.
    
    * bindings/js/JSDOMBinding.cpp:
    (WebCore::removeWrappers):
    (WebCore::hasCachedDOMObjectWrapperUnchecked):
    (WebCore::hasCachedDOMObjectWrapper):
    (WebCore::hasCachedDOMNodeWrapperUnchecked):
    (WebCore::forgetDOMObject):
    (WebCore::forgetDOMNode):
    (WebCore::isObservableThroughDOM):
    (WebCore::markDOMNodesForDocument):
    (WebCore::markDOMObjectWrapper):
    (WebCore::markDOMNodeWrapper):
    * bindings/js/JSDOMBinding.h: Changed DOM wrapper maps to be WeakGCMaps.
    Don't ASSERT that an item must be in the WeakGCMap when its destructor
    runs, since it might have been overwritten in the map first.
    
    * bindings/js/JSDocumentCustom.cpp:
    (WebCore::toJS): Changed Document from a DOM object wrapper to a DOM node
    wrapper, to simplify some code.
    
    * bindings/js/JSInspectedObjectWrapper.cpp:
    (WebCore::JSInspectedObjectWrapper::JSInspectedObjectWrapper):
    (WebCore::JSInspectedObjectWrapper::~JSInspectedObjectWrapper):
    * bindings/js/JSInspectorCallbackWrapper.cpp: Use a WeakGCMap for these
    wrappers.
    
    * bindings/js/JSNodeCustom.cpp:
    (WebCore::JSNode::markChildren): Updated for WeakGCMap and Document using
    a DOM node wrapper instead of a DOM object wrapper.
    
    * bindings/js/JSSVGPODTypeWrapper.h:
    (WebCore::JSSVGDynamicPODTypeWrapperCache::wrapperMap):
    (WebCore::JSSVGDynamicPODTypeWrapperCache::lookupOrCreateWrapper):
    (WebCore::JSSVGDynamicPODTypeWrapperCache::forgetWrapper):
    (WebCore::::~JSSVGDynamicPODTypeWrapper): Shined a small beam of sanity light
    on this code. Use hashtable-based lookup in JSSVGPODTypeWrapper.h instead
    of linear lookup through iteration, since that's what hashtables were
    invented for. Make JSSVGPODTypeWrapper.h responsible for reomving itself
    from the table, instead of its JS wrapper, to decouple these objects from
    GC, and because these objects are refCounted, not solely owned by their
    JS wrappers.
    
    * bindings/scripts/CodeGeneratorJS.pm:
    * dom/Document.h: Adopted changes above.
    
    
    
    git-svn-id: http://svn.webkit.org/repository/webkit/trunk@52082 268f45cc-cd09-0410-ab3c-d52691b4dbfc
    6a429819
JSArray.cpp 35.4 KB