Changeset 197379 in webkit for trunk/Source/JavaScriptCore/runtime

Timestamp:

Feb 29, 2016, 6:07:12 PM (9 years ago)

Author:

[email protected]

Message:

Add new MethodTable method to get an estimated size for a cell
​https://bugs.webkit.org/show_bug.cgi?id=154838

Patch by Joseph Pecoraro <Joseph Pecoraro> on 2016-02-29
Reviewed by Filip Pizlo.

The new class method estimatedSize(JSCell*) estimates the size for a single cell.
As the name implies, this is meant to be an approximation. It is more important
that big objects report a large size, then to get perfect size information for
all objects in the heap.

Base implementation (JSCell):

• returns the MarkedBlock bucket size for this cell.
• This gets us the object size include inline storage. Basically a better sizeof.

Subclasses with "Extra Memory Cost":

• Any class that reports extra memory (reportExtraMemoryVisited) should include that in the estimated size.
• E.g. CodeBlock, JSGenericTypedArrayView, WeakMapData, etc.

Subclasses with "Copied Space" storage:

• Any class with data in copied space (copyBackingStore) should include that in the estimated size.
• E.g. JSObject, JSGenericTypedArrayView, JSMap, JSSet, DirectArguments, etc.

Add reportExtraMemoryVisited for UnlinkedCodeBlock's compressed unlinked
instructions because this can be larger than 1kb, which is significant.

This has one special case for RegExp generated bytecode / JIT code, which
does not currently fall into the extra memory cost or copied space storage.
In practice I haven't seen this grow to a significant cost.

• runtime/ClassInfo.h:

Add the new estimatedSize method to the table.

• bytecode/UnlinkedCodeBlock.cpp:

(JSC::UnlinkedCodeBlock::visitChildren):
(JSC::UnlinkedCodeBlock::estimatedSize):
(JSC::UnlinkedCodeBlock::setInstructions):

• bytecode/UnlinkedCodeBlock.h:

Report an extra memory cost for unlinked code blocks like
we do for linked code blocks.

• bytecode/CodeBlock.cpp:

(JSC::CodeBlock::estimatedSize):

• bytecode/CodeBlock.h:
• bytecode/UnlinkedInstructionStream.cpp:

(JSC::UnlinkedInstructionStream::sizeInBytes):

• bytecode/UnlinkedInstructionStream.h:
• runtime/DirectArguments.cpp:

(JSC::DirectArguments::estimatedSize):

• runtime/DirectArguments.h:
• runtime/JSCell.cpp:

(JSC::JSCell::estimatedSizeInBytes):
(JSC::JSCell::estimatedSize):

• runtime/JSCell.h:
• runtime/JSGenericTypedArrayView.h:
• runtime/JSGenericTypedArrayViewInlines.h:

(JSC::JSGenericTypedArrayView<Adaptor>::estimatedSize):

• runtime/JSMap.cpp:

(JSC::JSMap::estimatedSize):

• runtime/JSMap.h:
• runtime/JSObject.cpp:

(JSC::JSObject::visitButterfly):

• runtime/JSObject.h:
• runtime/JSSet.cpp:

(JSC::JSSet::estimatedSize):

• runtime/JSSet.h:
• runtime/JSString.cpp:

(JSC::JSString::estimatedSize):

• runtime/JSString.h:
• runtime/MapData.h:

(JSC::MapDataImpl::capacityInBytes):

• runtime/WeakMapData.cpp:

(JSC::WeakMapData::estimatedSize):
(JSC::WeakMapData::visitChildren):

• runtime/WeakMapData.h:

Implement estimated size following the pattern of reporting
extra visited size, or copy space memory.

• runtime/RegExp.cpp:

(JSC::RegExp::estimatedSize):

• runtime/RegExp.h:
• yarr/YarrInterpreter.h:

(JSC::Yarr::ByteDisjunction::estimatedSizeInBytes):
(JSC::Yarr::BytecodePattern::estimatedSizeInBytes):

• yarr/YarrJIT.h:

(JSC::Yarr::YarrCodeBlock::size):
Include generated bytecode / JITCode to a RegExp's size.

Location:

trunk/Source/JavaScriptCore/runtime

Files:

• ClassInfo.h (modified) (2 diffs)
• DirectArguments.cpp (modified) (1 diff)
• DirectArguments.h (modified) (1 diff)
• JSCell.cpp (modified) (1 diff)
• JSCell.h (modified) (1 diff)
• JSGenericTypedArrayView.h (modified) (1 diff)
• JSGenericTypedArrayViewInlines.h (modified) (1 diff)
• JSMap.cpp (modified) (1 diff)
• JSMap.h (modified) (1 diff)
• JSObject.cpp (modified) (1 diff)
• JSObject.h (modified) (1 diff)
• JSSet.cpp (modified) (1 diff)
• JSSet.h (modified) (1 diff)
• JSString.cpp (modified) (1 diff)
• JSString.h (modified) (1 diff)
• MapData.h (modified) (2 diffs)
• RegExp.cpp (modified) (1 diff)
• RegExp.h (modified) (1 diff)
• WeakMapData.cpp (modified) (2 diffs)
• WeakMapData.h (modified) (1 diff)

trunk/Source/JavaScriptCore/runtime/ClassInfo.h

@@ -106 +106 @@
     typedef void (*DumpToStreamFunctionPtr)(const JSCell*, PrintStream&);
     DumpToStreamFunctionPtr dumpToStream;
+
+    typedef size_t (*EstimatedSizeFunctionPtr)(JSCell*);
+    EstimatedSizeFunctionPtr estimatedSize;
 };
 
@@ -152 +155 @@
         &ClassName::slowDownAndWasteMemory, \
         &ClassName::getTypedArrayImpl, \
-        &ClassName::dumpToStream \
+        &ClassName::dumpToStream, \
+        &ClassName::estimatedSize \
     }, \
     ClassName::TypedArrayStorageType

trunk/Source/JavaScriptCore/runtime/DirectArguments.cpp

@@ -84 +84 @@
     
     return result;
+}
+
+size_t DirectArguments::estimatedSize(JSCell* cell)
+{
+    DirectArguments* thisObject = jsCast<DirectArguments*>(cell);
+    size_t overridesSize = thisObject->m_overrides ? thisObject->overridesSize() : 0;
+    return Base::estimatedSize(cell) + overridesSize;
 }
 

trunk/Source/JavaScriptCore/runtime/DirectArguments.h

@@ -56 +56 @@
     // Creates an arguments object by copying the argumnets from the stack.
     static DirectArguments* createByCopying(ExecState*);
-    
+
+    static size_t estimatedSize(JSCell*);
     static void visitChildren(JSCell*, SlotVisitor&);
     static void copyBackingStore(JSCell*, CopyVisitor&, CopyToken);

trunk/Source/JavaScriptCore/runtime/JSCell.cpp

@@ -52 +52 @@
 }
 
+size_t JSCell::estimatedSizeInBytes() const
+{
+    return methodTable()->estimatedSize(const_cast<JSCell*>(this));
+}
+
+size_t JSCell::estimatedSize(JSCell* cell)
+{
+    return MarkedBlock::blockFor(cell)->cellSize();
+}
+
 void JSCell::copyBackingStore(JSCell*, CopyVisitor&, CopyToken)
 {

trunk/Source/JavaScriptCore/runtime/JSCell.h

@@ -135 +135 @@
     void dump(PrintStream&) const;
     JS_EXPORT_PRIVATE static void dumpToStream(const JSCell*, PrintStream&);
+
+    size_t estimatedSizeInBytes() const;
+    JS_EXPORT_PRIVATE static size_t estimatedSize(JSCell*);
+
     static void visitChildren(JSCell*, SlotVisitor&);
     JS_EXPORT_PRIVATE static void copyBackingStore(JSCell*, CopyVisitor&, CopyToken);

trunk/Source/JavaScriptCore/runtime/JSGenericTypedArrayView.h

@@ -284 +284 @@
     
     static void getOwnPropertyNames(JSObject*, ExecState*, PropertyNameArray&, EnumerationMode);
-    
+
+    static size_t estimatedSize(JSCell*);
     static void visitChildren(JSCell*, SlotVisitor&);
     static void copyBackingStore(JSCell*, CopyVisitor&, CopyToken);

trunk/Source/JavaScriptCore/runtime/JSGenericTypedArrayViewInlines.h

@@ -407 +407 @@
 
 template<typename Adaptor>
+size_t JSGenericTypedArrayView<Adaptor>::estimatedSize(JSCell* cell)
+{
+    JSGenericTypedArrayView* thisObject = jsCast<JSGenericTypedArrayView*>(cell);
+
+    if (thisObject->m_mode == OversizeTypedArray)
+        return Base::estimatedSize(thisObject) + thisObject->byteSize();
+    if (thisObject->m_mode == FastTypedArray && thisObject->m_vector)
+        return Base::estimatedSize(thisObject) + thisObject->byteSize();
+
+    return Base::estimatedSize(thisObject);
+}
+
+template<typename Adaptor>
 void JSGenericTypedArrayView<Adaptor>::visitChildren(JSCell* cell, SlotVisitor& visitor)
 {

trunk/Source/JavaScriptCore/runtime/JSMap.cpp

@@ -42 +42 @@
     JSMap* thisObject = jsCast<JSMap*>(cell);
     thisObject->JSMap::~JSMap();
+}
+
+size_t JSMap::estimatedSize(JSCell* cell)
+{
+    JSMap* thisObject = jsCast<JSMap*>(cell);
+    size_t mapDataSize = thisObject->m_mapData.capacityInBytes();
+    return Base::estimatedSize(cell) + mapDataSize;
 }
 

trunk/Source/JavaScriptCore/runtime/JSMap.h

@@ -123 +123 @@
 
     static void destroy(JSCell*);
+    static size_t estimatedSize(JSCell*);
     static void visitChildren(JSCell*, SlotVisitor&);
     static void copyBackingStore(JSCell*, CopyVisitor&, CopyToken);

trunk/Source/JavaScriptCore/runtime/JSObject.cpp

@@ -196 +196 @@
         break;
     }
+}
+
+size_t JSObject::estimatedSize(JSCell* cell)
+{
+    JSObject* thisObject = jsCast<JSObject*>(cell);
+    size_t butterflyOutOfLineSize = thisObject->m_butterfly ? thisObject->structure()->outOfLineSize() : 0;
+    return Base::estimatedSize(cell) + butterflyOutOfLineSize;
 }
 

trunk/Source/JavaScriptCore/runtime/JSObject.h

@@ -95 +95 @@
 public:
     typedef JSCell Base;
-        
+
+    JS_EXPORT_PRIVATE static size_t estimatedSize(JSCell*);
     JS_EXPORT_PRIVATE static void visitChildren(JSCell*, SlotVisitor&);
     JS_EXPORT_PRIVATE static void copyBackingStore(JSCell*, CopyVisitor&, CopyToken);

trunk/Source/JavaScriptCore/runtime/JSSet.cpp

@@ -44 +44 @@
 }
 
+size_t JSSet::estimatedSize(JSCell* cell)
+{
+    JSSet* thisObject = jsCast<JSSet*>(cell);
+    size_t setDataSize = thisObject->m_setData.capacityInBytes();
+    return Base::estimatedSize(cell) + setDataSize;
+}
+
 void JSSet::visitChildren(JSCell* cell, SlotVisitor& visitor)
 {

trunk/Source/JavaScriptCore/runtime/JSSet.h

@@ -118 +118 @@
 
     static void destroy(JSCell*);
+    static size_t estimatedSize(JSCell*);
     static void visitChildren(JSCell*, SlotVisitor&);
     static void copyBackingStore(JSCell*, CopyVisitor&, CopyToken);

trunk/Source/JavaScriptCore/runtime/JSString.cpp

@@ -73 +73 @@
 }
 
+size_t JSString::estimatedSize(JSCell* cell)
+{
+    JSString* thisObject = jsCast<JSString*>(cell);
+    if (thisObject->isRope())
+        return Base::estimatedSize(cell);
+    return Base::estimatedSize(cell) + thisObject->m_value.impl()->costDuringGC();
+}
+
 void JSString::visitChildren(JSCell* cell, SlotVisitor& visitor)
 {

trunk/Source/JavaScriptCore/runtime/JSString.h

@@ -182 +182 @@
 
     static void dumpToStream(const JSCell*, PrintStream&);
+    static size_t estimatedSize(JSCell*);
     static void visitChildren(JSCell*, SlotVisitor&);
 

trunk/Source/JavaScriptCore/runtime/MapData.h

@@ -112 +112 @@
     void copyBackingStore(CopyVisitor&, CopyToken);
 
+    size_t capacityInBytes() const { return m_capacity * sizeof(Entry); }
+
 private:
     typedef WTF::UnsignedWithZeroKeyHashTraits<int32_t> IndexTraits;
@@ -119 +121 @@
     typedef HashMap<StringImpl*, int32_t, typename WTF::DefaultHash<StringImpl*>::Hash, WTF::HashTraits<StringImpl*>, IndexTraits> StringKeyedMap;
     typedef HashMap<SymbolImpl*, int32_t, typename WTF::PtrHash<SymbolImpl*>, WTF::HashTraits<SymbolImpl*>, IndexTraits> SymbolKeyedMap;
-
-    size_t capacityInBytes() { return m_capacity * sizeof(Entry); }
 
     ALWAYS_INLINE Entry* find(ExecState*, KeyType);

trunk/Source/JavaScriptCore/runtime/RegExp.cpp

@@ -257 +257 @@
 }
 
+size_t RegExp::estimatedSize(JSCell* cell)
+{
+    RegExp* thisObject = static_cast<RegExp*>(cell);
+    size_t regexDataSize = thisObject->m_regExpBytecode ? thisObject->m_regExpBytecode->estimatedSizeInBytes() : 0;
+#if ENABLE(YARR_JIT)
+    regexDataSize += thisObject->m_regExpJITCode.size();
+#endif
+    return Base::estimatedSize(cell) + regexDataSize;
+}
+
 RegExp* RegExp::createWithoutCaching(VM& vm, const String& patternString, RegExpFlags flags)
 {

trunk/Source/JavaScriptCore/runtime/RegExp.h

@@ -51 +51 @@
     static const bool needsDestruction = true;
     static void destroy(JSCell*);
+    static size_t estimatedSize(JSCell*);
 
     bool global() const { return m_flags & FlagGlobal; }

trunk/Source/JavaScriptCore/runtime/WeakMapData.cpp

@@ -55 +55 @@
 }
 
+size_t WeakMapData::estimatedSize(JSCell* cell)
+{
+    WeakMapData* thisObj = jsCast<WeakMapData*>(cell);
+    return Base::estimatedSize(cell) + (thisObj->m_map.capacity() * (sizeof(JSObject*) + sizeof(WriteBarrier<Unknown>)));
+}
+
 void WeakMapData::visitChildren(JSCell* cell, SlotVisitor& visitor)
 {
@@ -64 +70 @@
     // Rough approximation of the external storage needed for the hashtable.
     // This isn't exact, but it is close enough, and proportional to the actual
-    // external mermory usage.
+    // external memory usage.
     visitor.reportExtraMemoryVisited(thisObj->m_map.capacity() * (sizeof(JSObject*) + sizeof(WriteBarrier<Unknown>)));
 }

trunk/Source/JavaScriptCore/runtime/WeakMapData.h

@@ -71 +71 @@
     WeakMapData(VM&);
     static void destroy(JSCell*);
+    static size_t estimatedSize(JSCell*);
     static void visitChildren(JSCell*, SlotVisitor&);
     void finishCreation(VM&);