Changeset 122243 in webkit


Ignore:
Timestamp:
Jul 10, 2012 12:10:43 PM (12 years ago)
Author:
commit-queue@webkit.org
Message:

Web Inspector: Count inspector memory used to traverse DOM in native memory snapshots.
https://bugs.webkit.org/show_bug.cgi?id=90456

Inspector may take significant amount of memory when traversing DOM structure.
Take it into account and report under inspector memory.

Patch by Alexei Filippov <alexeif@chromium.org> on 2012-07-10
Reviewed by Pavel Feldman.

  • dom/MemoryInstrumentation.h:

(MemoryInstrumentation):
(WebCore::MemoryInstrumentation::calculateContainerSize):
(WebCore::MemoryInstrumentation::reportHashMap):
(WebCore::MemoryInstrumentation::reportHashSet):
(WebCore::MemoryInstrumentation::reportVector):

  • inspector/InspectorMemoryAgent.cpp:

(MemoryBlockName):
(WebCore):
(WebCore::domTreeInfo):
(WebCore::InspectorMemoryAgent::getProcessMemoryDistribution):

Location:
trunk/Source/WebCore
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/WebCore/ChangeLog

    r122233 r122243  
     12012-07-10  Alexei Filippov  <alexeif@chromium.org>
     2
     3        Web Inspector: Count inspector memory used to traverse DOM in native memory snapshots.
     4        https://bugs.webkit.org/show_bug.cgi?id=90456
     5
     6        Inspector may take significant amount of memory when traversing DOM structure.
     7        Take it into account and report under inspector memory.
     8
     9        Reviewed by Pavel Feldman.
     10
     11        * dom/MemoryInstrumentation.h:
     12        (MemoryInstrumentation):
     13        (WebCore::MemoryInstrumentation::calculateContainerSize):
     14        (WebCore::MemoryInstrumentation::reportHashMap):
     15        (WebCore::MemoryInstrumentation::reportHashSet):
     16        (WebCore::MemoryInstrumentation::reportVector):
     17        * inspector/InspectorMemoryAgent.cpp:
     18        (MemoryBlockName):
     19        (WebCore):
     20        (WebCore::domTreeInfo):
     21        (WebCore::InspectorMemoryAgent::getProcessMemoryDistribution):
     22
    1232012-07-10  Sudarsana Nagineni  <sudarsana.nagineni@linux.intel.com>
    224
  • trunk/Source/WebCore/dom/MemoryInstrumentation.h

    r121952 r122243  
    7575    };
    7676
     77    template <typename Container>
     78    size_t calculateContainerSize(const Container& container, bool contentOnly = false)
     79    {
     80        return (contentOnly ? 0 : sizeof(container)) + container.capacity() * sizeof(typename Container::ValueType);
     81    }
     82
    7783private:
    7884    friend class MemoryObjectInfo;
     
    193199void MemoryInstrumentation::reportHashMap(const HashMapType& hashMap, ObjectType objectType, bool contentOnly)
    194200{
    195     size_t size = (contentOnly ? 0 : sizeof(HashMapType)) + hashMap.capacity() * sizeof(typename HashMapType::ValueType);
    196     countObjectSize(objectType, size);
     201    countObjectSize(objectType, calculateContainerSize(hashMap, contentOnly));
    197202}
    198203
     
    202207    if (visited(&hashSet))
    203208        return;
    204     size_t size = (contentOnly ? 0 : sizeof(HashSetType)) + hashSet.capacity() * sizeof(typename HashSetType::ValueType);
    205     countObjectSize(objectType, size);
     209    countObjectSize(objectType, calculateContainerSize(hashSet, contentOnly));
    206210}
    207211
     
    220224    if (visited(vector.data()))
    221225        return;
    222     size_t size = (contentOnly ? 0 : sizeof(VectorType)) + vector.capacity() * sizeof(typename VectorType::ValueType);
    223     countObjectSize(objectType, size);
     226    countObjectSize(objectType, calculateContainerSize(vector, contentOnly));
    224227}
    225228
  • trunk/Source/WebCore/inspector/InspectorMemoryAgent.cpp

    r122087 r122243  
    7979static const char jsExternalStrings[] = "JSExternalStrings";
    8080static const char inspectorData[] = "InspectorData";
     81static const char inspectorDOMData[] = "InspectorDOMData";
     82static const char inspectorJSHeapData[] = "InspectorJSHeapData";
    8183static const char memoryCache[] = "MemoryCache";
    8284static const char processPrivateMemory[] = "ProcessPrivateMemory";
     
    110112size_t stringSize(StringImpl* string)
    111113{
    112     // TODO: support substrings
     114    // FIXME: support substrings
    113115    size_t size = string->length();
    114116    if (string->is8Bit()) {
     
    358360};
    359361
     362class InspectorDataCounter {
     363public:
     364    void addComponent(const String& name, size_t size)
     365    {
     366        m_components.append(ComponentInfo(name, size));
     367    }
     368
     369    PassRefPtr<InspectorMemoryBlock> dumpStatistics()
     370    {
     371        size_t totalSize = 0;
     372        RefPtr<InspectorMemoryBlock> block = InspectorMemoryBlock::create().setName(MemoryBlockName::inspectorData);
     373        for (Vector<ComponentInfo>::iterator it = m_components.begin(); it != m_components.end(); ++it) {
     374            RefPtr<InspectorMemoryBlock> block = InspectorMemoryBlock::create().setName(it->m_name);
     375            block->setSize(it->m_size);
     376            totalSize += it->m_size;
     377        }
     378        block->setSize(totalSize);
     379        return block;
     380    }
     381
     382private:
     383    class ComponentInfo {
     384    public:
     385        ComponentInfo(const String& name, size_t size) : m_name(name), m_size(size) { }
     386
     387        const String m_name;
     388        size_t m_size;
     389    };
     390
     391    Vector<ComponentInfo> m_components;
     392};
     393
    360394} // namespace
    361395
     
    400434}
    401435
    402 static PassRefPtr<InspectorMemoryBlock> inspectorData()
    403 {
    404     size_t dataSize = ScriptProfiler::profilerSnapshotsSize();
    405     RefPtr<InspectorMemoryBlock> inspectorData = InspectorMemoryBlock::create().setName(MemoryBlockName::inspectorData);
    406     inspectorData->setSize(dataSize);
    407     return inspectorData.release();
    408 }
    409 
    410436static PassRefPtr<InspectorMemoryBlock> renderTreeInfo(Page* page)
    411437{
     
    442468    }
    443469
    444     PassRefPtr<InspectorMemoryBlock> dumpStatistics()
    445     {
     470    PassRefPtr<InspectorMemoryBlock> dumpStatistics(InspectorDataCounter* inspectorData)
     471    {
     472        size_t inspectorSize
     473            = calculateContainerSize(m_visitedObjects)
     474            + calculateContainerSize(m_deferredInstrumentedPointers);
     475        inspectorData->addComponent(MemoryBlockName::inspectorDOMData, inspectorSize);
     476
    446477        size_t totalSize = 0;
    447478        for (int i = Other; i < LastTypeEntry; ++i)
     
    520551    }
    521552
    522     PassRefPtr<InspectorMemoryBlock> dumpStatistics() { return m_domMemoryUsage.dumpStatistics(); }
     553    PassRefPtr<InspectorMemoryBlock> dumpStatistics(InspectorDataCounter* inspectorData)
     554    {
     555        return m_domMemoryUsage.dumpStatistics(inspectorData);
     556    }
    523557
    524558private:
     
    529563}
    530564
    531 static PassRefPtr<InspectorMemoryBlock> domTreeInfo(Page* page, VisitedObjects& visitedObjects)
     565static PassRefPtr<InspectorMemoryBlock> domTreeInfo(Page* page, VisitedObjects& visitedObjects, InspectorDataCounter* inspectorData)
    532566{
    533567    DOMTreesIterator domTreesIterator(page, visitedObjects);
     
    542576    domTreesIterator.visitBindings();
    543577
    544     return domTreesIterator.dumpStatistics();
     578    return domTreesIterator.dumpStatistics(inspectorData);
    545579}
    546580
     
    589623void InspectorMemoryAgent::getProcessMemoryDistribution(ErrorString*, RefPtr<InspectorMemoryBlock>& processMemory)
    590624{
     625    processMemory = InspectorMemoryBlock::create().setName(MemoryBlockName::processPrivateMemory);
     626
     627    InspectorDataCounter inspectorData;
     628    inspectorData.addComponent(MemoryBlockName::inspectorJSHeapData, ScriptProfiler::profilerSnapshotsSize());
     629
     630    VisitedObjects visitedObjects;
     631    RefPtr<TypeBuilder::Array<InspectorMemoryBlock> > children = TypeBuilder::Array<InspectorMemoryBlock>::create();
     632    children->addItem(jsHeapInfo());
     633    children->addItem(memoryCacheInfo());
     634    children->addItem(renderTreeInfo(m_page)); // FIXME: collect for all pages?
     635    children->addItem(domTreeInfo(m_page, visitedObjects, &inspectorData)); // FIXME: collect for all pages?
     636    children->addItem(jsExternalResourcesInfo(visitedObjects));
     637    children->addItem(inspectorData.dumpStatistics());
     638    processMemory->setChildren(children);
     639
    591640    size_t privateBytes = 0;
    592641    size_t sharedBytes = 0;
    593642    MemoryUsageSupport::processMemorySizesInBytes(&privateBytes, &sharedBytes);
    594     processMemory = InspectorMemoryBlock::create().setName(MemoryBlockName::processPrivateMemory);
    595643    processMemory->setSize(privateBytes);
    596 
    597     VisitedObjects visitedObjects;
    598     RefPtr<TypeBuilder::Array<InspectorMemoryBlock> > children = TypeBuilder::Array<InspectorMemoryBlock>::create();
    599     children->addItem(jsHeapInfo());
    600     children->addItem(inspectorData());
    601     children->addItem(memoryCacheInfo());
    602     children->addItem(renderTreeInfo(m_page)); // TODO: collect for all pages?
    603     children->addItem(domTreeInfo(m_page, visitedObjects)); // TODO: collect for all pages?
    604     children->addItem(jsExternalResourcesInfo(visitedObjects));
    605     processMemory->setChildren(children);
    606644}
    607645
Note: See TracChangeset for help on using the changeset viewer.