Changeset 127738 in webkit

Timestamp:

Sep 6, 2012 7:25:47 AM (12 years ago)

Author:

loislo@chromium.org

Message:

Web Inspector: NMI: switch to hierarchical identifiers of MemoryBlockTypes and use these identifiers in protocol.
​https://bugs.webkit.org/show_bug.cgi?id=95957

Reviewed by Yury Semikhatsky.

Source/WebCore:

Now when we use string identifiers as MemoryObjectType we can use them as the identifiers for the protocol
instead of MemoryBlockNames hardcoded in InspectorMemoryAgent..
At a later stage, when each type of memory will be counted in MemoryInstrumentation
we will build the blocks hierarchy for the front-end automatically.

• dom/MemoryInstrumentation.cpp:

(WebCore):

• dom/MemoryInstrumentation.h:

(GenericMemoryTypes):
(WebCore::MemoryInstrumentation::addRootObject):
(WebCore::MemoryObjectInfo::reportObjectInfo):
(WebCoreMemoryTypes):

• inspector/InspectorMemoryAgent.cpp:

(MemoryBlockName):
(WebCore):

• inspector/MemoryInstrumentationImpl.cpp:

(WebCore::MemoryInstrumentationImpl::countObjectSize):

• inspector/front-end/NativeMemorySnapshotView.js:

(WebInspector.MemoryBlockViewProperties._initialize):

• loader/cache/CachedRawResource.cpp:

(WebCore::CachedRawResource::reportMemoryUsage):

• loader/cache/CachedResource.cpp:

(WebCore::CachedResource::reportMemoryUsage):

• loader/cache/CachedResourceHandle.cpp:

(WebCore::CachedResourceHandleBase::reportMemoryUsage):

• platform/SharedBuffer.cpp:

(WebCore::SharedBuffer::reportMemoryUsage):

Source/WebKit/chromium:

Now when we use string identifiers as MemoryObjectType we can use them as the identifiers for the protocol
instead of MemoryBlockNames hardcoded in InspectorMemoryAgent..
At a later stage, when each memory type is counted in MemoryInstrumentation
we will build the blocks hierarchy for the front-end automatically.

• tests/MemoryInstrumentationTest.cpp:

(WebCore::InstrumentedUndefined::InstrumentedUndefined):
(WebCore::InstrumentedUndefined::reportMemoryUsage):
(WebCore::InstrumentedDOM::InstrumentedDOM):
(WebCore::InstrumentedDOM::reportMemoryUsage):
(InstrumentedDOM):
(WebCore::TEST):

Location:

trunk/Source

Files:

• WebCore/ChangeLog (modified) (1 diff)
• WebCore/dom/MemoryInstrumentation.cpp (modified) (1 diff)
• WebCore/dom/MemoryInstrumentation.h (modified) (4 diffs)
• WebCore/inspector/InspectorMemoryAgent.cpp (modified) (5 diffs)
• WebCore/inspector/MemoryInstrumentationImpl.cpp (modified) (1 diff)
• WebCore/inspector/front-end/NativeMemorySnapshotView.js (modified) (1 diff)
• WebCore/loader/cache/CachedRawResource.cpp (modified) (1 diff)
• WebCore/loader/cache/CachedResourceHandle.cpp (modified) (1 diff)
• WebCore/platform/SharedBuffer.cpp (modified) (1 diff)
• WebKit/chromium/ChangeLog (modified) (1 diff)
• WebKit/chromium/tests/MemoryInstrumentationTest.cpp (modified) (3 diffs)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2012-09-06  Ilya Tikhonovsky  <loislo@chromium.org>
+
+        Web Inspector: NMI: switch to hierarchical identifiers of MemoryBlockTypes and use these identifiers in protocol.
+        https://bugs.webkit.org/show_bug.cgi?id=95957
+
+        Reviewed by Yury Semikhatsky.
+
+        Now when we use string identifiers as MemoryObjectType we can use them as the identifiers for the protocol
+        instead of MemoryBlockNames hardcoded in InspectorMemoryAgent..
+        At a later stage, when each type of memory will be counted in MemoryInstrumentation
+        we will build the blocks hierarchy for the front-end automatically.
+
+        * dom/MemoryInstrumentation.cpp:
+        (WebCore):
+        * dom/MemoryInstrumentation.h:
+        (GenericMemoryTypes):
+        (WebCore::MemoryInstrumentation::addRootObject):
+        (WebCore::MemoryObjectInfo::reportObjectInfo):
+        (WebCoreMemoryTypes):
+        * inspector/InspectorMemoryAgent.cpp:
+        (MemoryBlockName):
+        (WebCore):
+        * inspector/MemoryInstrumentationImpl.cpp:
+        (WebCore::MemoryInstrumentationImpl::countObjectSize):
+        * inspector/front-end/NativeMemorySnapshotView.js:
+        (WebInspector.MemoryBlockViewProperties._initialize):
+        * loader/cache/CachedRawResource.cpp:
+        (WebCore::CachedRawResource::reportMemoryUsage):
+        * loader/cache/CachedResource.cpp:
+        (WebCore::CachedResource::reportMemoryUsage):
+        * loader/cache/CachedResourceHandle.cpp:
+        (WebCore::CachedResourceHandleBase::reportMemoryUsage):
+        * platform/SharedBuffer.cpp:
+        (WebCore::SharedBuffer::reportMemoryUsage):
+
 2012-09-06  Mikhail Pozdnyakov  <mikhail.pozdnyakov@intel.com>
 

trunk/Source/WebCore/dom/MemoryInstrumentation.cpp

@@ -38 +38 @@
 namespace WebCore {
 
-MemoryObjectType GenericMemoryTypes::Other = "Other";
+MemoryObjectType GenericMemoryTypes::Undefined = 0;
 
-MemoryObjectType WebCoreMemoryTypes::DOM = "DOM";
-MemoryObjectType WebCoreMemoryTypes::CSS = "CSS";
-MemoryObjectType WebCoreMemoryTypes::Binding = "Binding";
-MemoryObjectType WebCoreMemoryTypes::Loader = "Loader";
-MemoryObjectType WebCoreMemoryTypes::MemoryCacheStructures = "MemoryCacheStructures";
-MemoryObjectType WebCoreMemoryTypes::CachedResource = "CachedResource";
-MemoryObjectType WebCoreMemoryTypes::CachedResourceCSS = "CachedResourceCSS";
-MemoryObjectType WebCoreMemoryTypes::CachedResourceFont = "CachedResourceFont";
-MemoryObjectType WebCoreMemoryTypes::CachedResourceImage = "CachedResourceImage";
-MemoryObjectType WebCoreMemoryTypes::CachedResourceScript = "CachedResourceScript";
-MemoryObjectType WebCoreMemoryTypes::CachedResourceSVG = "CachedResourceSVG";
-MemoryObjectType WebCoreMemoryTypes::CachedResourceShader = "CachedResourceShader";
-MemoryObjectType WebCoreMemoryTypes::CachedResourceXSLT = "CachedResourceXSLT";
+MemoryObjectType WebCoreMemoryTypes::Page = "Page";
+MemoryObjectType WebCoreMemoryTypes::DOM = "Page.DOM";
+MemoryObjectType WebCoreMemoryTypes::CSS = "Page.CSS";
+MemoryObjectType WebCoreMemoryTypes::Binding = "Page.Binding";
+MemoryObjectType WebCoreMemoryTypes::Loader = "Page.Loader";
+
+MemoryObjectType WebCoreMemoryTypes::MemoryCache = "MemoryCache";
+MemoryObjectType WebCoreMemoryTypes::MemoryCacheStructures = "MemoryCache.InternalStructures";
+MemoryObjectType WebCoreMemoryTypes::CachedResource = "MemoryCache.Resource";
+MemoryObjectType WebCoreMemoryTypes::CachedResourceRaw = "MemoryCache.RawResource";
+MemoryObjectType WebCoreMemoryTypes::CachedResourceCSS = "MemoryCache.CSS";
+MemoryObjectType WebCoreMemoryTypes::CachedResourceFont = "MemoryCache.Font";
+MemoryObjectType WebCoreMemoryTypes::CachedResourceImage = "MemoryCache.Image";
+MemoryObjectType WebCoreMemoryTypes::CachedResourceScript = "MemoryCache.Script";
+MemoryObjectType WebCoreMemoryTypes::CachedResourceSVG = "MemoryCache.SVG";
+MemoryObjectType WebCoreMemoryTypes::CachedResourceShader = "MemoryCache.Shader";
+MemoryObjectType WebCoreMemoryTypes::CachedResourceXSLT = "MemoryCache.XSLT";
 
 template<> void MemoryInstrumentationTraits::addInstrumentedObject<String>(MemoryInstrumentation* instrumentation, const String* const& string, MemoryObjectType ownerObjectType, MemoryOwningType owningType)

trunk/Source/WebCore/dom/MemoryInstrumentation.h

@@ -50 +50 @@
 class GenericMemoryTypes {
 public:
-    static MemoryObjectType Other;
+    static MemoryObjectType Undefined;
 };
 
@@ -70 +70 @@
     template <typename T> void addRootObject(const T& t)
     {
-        addInstrumentedObject(t, GenericMemoryTypes::Other);
+        addInstrumentedObject(t, GenericMemoryTypes::Undefined);
         processDeferredInstrumentedPointers();
     }
@@ -189 +189 @@
         if (!m_objectSize) {
             m_objectSize = actualSize ? actualSize : sizeof(T);
-            if (objectType != GenericMemoryTypes::Other)
+            if (objectType != GenericMemoryTypes::Undefined)
                 m_objectType = objectType;
         }
@@ -409 +409 @@
 class WebCoreMemoryTypes {
 public:
+    static MemoryObjectType Page;
     static MemoryObjectType DOM;
     static MemoryObjectType CSS;
     static MemoryObjectType Binding;
     static MemoryObjectType Loader;
+
+    static MemoryObjectType MemoryCache;
     static MemoryObjectType MemoryCacheStructures;
     static MemoryObjectType CachedResource;
+    static MemoryObjectType CachedResourceRaw;
     static MemoryObjectType CachedResourceCSS;
     static MemoryObjectType CachedResourceFont;

trunk/Source/WebCore/inspector/InspectorMemoryAgent.cpp

@@ -84 +84 @@
 static const char processPrivateMemory[] = "ProcessPrivateMemory";
 
-static const char memoryCache[] = "MemoryCache";
-static const char memoryCacheStructures[] = "MemoryCacheStructures";
-static const char cachedResource[] = "CachedResource";
-static const char cachedResourceImage[] = "CachedImages";
-static const char cachedResourceCSS[] = "CachedCssStyleSheets";
-static const char cachedResourceScript[] = "CachedScripts";
-static const char cachedResourceXSL[] = "CachedXslStyleSheets";
-static const char cachedResourceFont[] = "CachedFonts";
-static const char cachedResourceSVG[] = "CachedSVGGraphics";
-static const char cachedResourceShader[] = "CachedShaders";
-static const char cachedResourceXSLT[] = "CachedShadersXSLT";
-
 static const char renderTreeUsed[] = "RenderTreeUsed";
 static const char renderTreeAllocated[] = "RenderTreeAllocated";
-
-static const char dom[] = "DOM";
-static const char domTreeOther[] = "DOMTreeOther";
-static const char domTreeDOM[] = "DOMTreeDOM";
-static const char domTreeCSS[] = "DOMTreeCSS";
-static const char domTreeBinding[] = "DOMTreeBinding";
-static const char domTreeLoader[] = "DOMTreeLoader";
 
 static const char domStorageCache[] = "DOMStorageCache";
@@ -441 +422 @@
 }
 
-static size_t addMemoryBlockFor(TypeBuilder::Array<InspectorMemoryBlock>* array, size_t size, const char* name)
-{
-    RefPtr<InspectorMemoryBlock> result = InspectorMemoryBlock::create().setName(name);
-    result->setSize(size);
-    array->addItem(result);
-    return size;
-}
-
 namespace {
 
@@ -487 +460 @@
 
         RefPtr<TypeBuilder::Array<InspectorMemoryBlock> > children = TypeBuilder::Array<InspectorMemoryBlock>::create();
-        totalSize += addMemoryBlockFor(children.get(), m_memoryInstrumentation.totalSize(WebCoreMemoryTypes::MemoryCacheStructures), MemoryBlockName::memoryCacheStructures);
-        totalSize += addMemoryBlockFor(children.get(), m_memoryInstrumentation.totalSize(WebCoreMemoryTypes::CachedResource), MemoryBlockName::cachedResource);
-        totalSize += addMemoryBlockFor(children.get(), m_memoryInstrumentation.totalSize(WebCoreMemoryTypes::CachedResourceCSS), MemoryBlockName::cachedResourceCSS);
-        totalSize += addMemoryBlockFor(children.get(), m_memoryInstrumentation.totalSize(WebCoreMemoryTypes::CachedResourceFont), MemoryBlockName::cachedResourceFont);
-        totalSize += addMemoryBlockFor(children.get(), m_memoryInstrumentation.totalSize(WebCoreMemoryTypes::CachedResourceImage), MemoryBlockName::cachedResourceImage);
-        totalSize += addMemoryBlockFor(children.get(), m_memoryInstrumentation.totalSize(WebCoreMemoryTypes::CachedResourceScript), MemoryBlockName::cachedResourceScript);
-        totalSize += addMemoryBlockFor(children.get(), m_memoryInstrumentation.totalSize(WebCoreMemoryTypes::CachedResourceSVG), MemoryBlockName::cachedResourceSVG);
-        totalSize += addMemoryBlockFor(children.get(), m_memoryInstrumentation.totalSize(WebCoreMemoryTypes::CachedResourceShader), MemoryBlockName::cachedResourceShader);
-        totalSize += addMemoryBlockFor(children.get(), m_memoryInstrumentation.totalSize(WebCoreMemoryTypes::CachedResourceXSLT), MemoryBlockName::cachedResourceXSLT);
-
-        RefPtr<InspectorMemoryBlock> block = InspectorMemoryBlock::create().setName(MemoryBlockName::memoryCache);
+        totalSize += addMemoryBlockFor(children.get(), WebCoreMemoryTypes::MemoryCacheStructures);
+        totalSize += addMemoryBlockFor(children.get(), WebCoreMemoryTypes::CachedResourceRaw);
+        totalSize += addMemoryBlockFor(children.get(), WebCoreMemoryTypes::CachedResourceCSS);
+        totalSize += addMemoryBlockFor(children.get(), WebCoreMemoryTypes::CachedResourceFont);
+        totalSize += addMemoryBlockFor(children.get(), WebCoreMemoryTypes::CachedResourceImage);
+        totalSize += addMemoryBlockFor(children.get(), WebCoreMemoryTypes::CachedResourceScript);
+        totalSize += addMemoryBlockFor(children.get(), WebCoreMemoryTypes::CachedResourceSVG);
+        totalSize += addMemoryBlockFor(children.get(), WebCoreMemoryTypes::CachedResourceShader);
+        totalSize += addMemoryBlockFor(children.get(), WebCoreMemoryTypes::CachedResourceXSLT);
+
+        RefPtr<InspectorMemoryBlock> block = InspectorMemoryBlock::create().setName(WebCoreMemoryTypes::MemoryCache);
         block->setSize(totalSize);
         block->setChildren(children.release());
@@ -503 +476 @@
     }
 
-    PassRefPtr<InspectorMemoryBlock> buildObjectForDOM() const
+    PassRefPtr<InspectorMemoryBlock> buildObjectForPage() const
     {
         size_t totalSize = 0;
 
         RefPtr<TypeBuilder::Array<InspectorMemoryBlock> > domChildren = TypeBuilder::Array<InspectorMemoryBlock>::create();
-        totalSize += addMemoryBlockFor(domChildren.get(), m_memoryInstrumentation.totalSize(GenericMemoryTypes::Other), MemoryBlockName::domTreeOther);
-        totalSize += addMemoryBlockFor(domChildren.get(), m_memoryInstrumentation.totalSize(WebCoreMemoryTypes::DOM), MemoryBlockName::domTreeDOM);
-        totalSize += addMemoryBlockFor(domChildren.get(), m_memoryInstrumentation.totalSize(WebCoreMemoryTypes::CSS), MemoryBlockName::domTreeCSS);
-        totalSize += addMemoryBlockFor(domChildren.get(), m_memoryInstrumentation.totalSize(WebCoreMemoryTypes::Binding), MemoryBlockName::domTreeBinding);
-        totalSize += addMemoryBlockFor(domChildren.get(), m_memoryInstrumentation.totalSize(WebCoreMemoryTypes::Loader), MemoryBlockName::domTreeLoader);
-
-        RefPtr<InspectorMemoryBlock> dom = InspectorMemoryBlock::create().setName(MemoryBlockName::dom);
+        totalSize += addMemoryBlockFor(domChildren.get(), WebCoreMemoryTypes::DOM);
+        totalSize += addMemoryBlockFor(domChildren.get(), WebCoreMemoryTypes::CSS);
+        totalSize += addMemoryBlockFor(domChildren.get(), WebCoreMemoryTypes::Binding);
+        totalSize += addMemoryBlockFor(domChildren.get(), WebCoreMemoryTypes::Loader);
+
+        RefPtr<InspectorMemoryBlock> dom = InspectorMemoryBlock::create().setName(WebCoreMemoryTypes::Page);
         dom->setSize(totalSize);
         dom->setChildren(domChildren.release());
@@ -523 +495 @@
     {
         children->addItem(buildObjectForMemoryCache());
-        children->addItem(buildObjectForDOM());
+        children->addItem(buildObjectForPage());
+
         inspectorData->addComponent(MemoryBlockName::inspectorDOMData, m_memoryInstrumentation.selfSize());
     }
 
 private:
+    size_t addMemoryBlockFor(TypeBuilder::Array<InspectorMemoryBlock>* array, MemoryObjectType typeName) const
+    {
+        RefPtr<InspectorMemoryBlock> result = InspectorMemoryBlock::create().setName(typeName);
+        size_t size = m_memoryInstrumentation.totalSize(typeName);
+        result->setSize(size);
+        array->addItem(result);
+        return size;
+    }
+
     Page* m_page;
     MemoryInstrumentationImpl& m_memoryInstrumentation;

trunk/Source/WebCore/inspector/MemoryInstrumentationImpl.cpp

@@ -53 +53 @@
 void MemoryInstrumentationImpl::countObjectSize(MemoryObjectType objectType, size_t size)
 {
+    ASSERT(objectType != GenericMemoryTypes::Undefined);
     TypeToSizeMap::AddResult result = m_totalSizes.add(objectType, size);
     if (!result.isNewEntry)

trunk/Source/WebCore/inspector/front-end/NativeMemorySnapshotView.js

@@ -217 +217 @@
     }
     addBlock("hsl(  0,  0%, 100%)", "ProcessPrivateMemory", "Total");
+    addBlock("hsl(  0,  0%,  80%)", "OwnersTypePlaceholder", "OwnersTypePlaceholder");
     addBlock("hsl(  0,  0%,  80%)", "Other", "Other");
-    addBlock("hsl(300, 30%,  80%)", "DOM", "DOM tree structures");
+    addBlock("hsl(300, 30%,  80%)", "Page", "Page's structures");
     addBlock("hsl( 90, 60%,  80%)", "JSHeapAllocated", "JavaScript heap");
     addBlock("hsl( 90, 80%,  80%)", "JSHeapUsed", "Used JavaScript heap");

trunk/Source/WebCore/loader/cache/CachedRawResource.cpp

@@ -163 +163 @@
 void CachedRawResource::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
 {
-    MemoryClassInfo info(memoryObjectInfo, this, WebCoreMemoryTypes::CachedResource);
+    MemoryClassInfo info(memoryObjectInfo, this, WebCoreMemoryTypes::CachedResourceRaw);
     CachedResource::reportMemoryUsage(memoryObjectInfo);
 }

trunk/Source/WebCore/loader/cache/CachedResourceHandle.cpp

@@ -44 +44 @@
 void CachedResourceHandleBase::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
 {
-    MemoryClassInfo info(memoryObjectInfo, this, WebCoreMemoryTypes::CachedResource);
+    MemoryClassInfo info(memoryObjectInfo, this, WebCoreMemoryTypes::MemoryCacheStructures);
     info.addInstrumentedMember(m_resource);
 }

trunk/Source/WebCore/platform/SharedBuffer.cpp

@@ -251 +251 @@
 void SharedBuffer::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
 {
-    MemoryClassInfo info(memoryObjectInfo, this, GenericMemoryTypes::Other);
+    MemoryClassInfo info(memoryObjectInfo, this, GenericMemoryTypes::Undefined);
     info.addVector(m_buffer);
     info.addVector(m_segments);

trunk/Source/WebKit/chromium/ChangeLog

@@ +1 @@
+2012-09-06  Ilya Tikhonovsky  <loislo@chromium.org>
+
+        Web Inspector: NMI: switch to hierarchical identifiers of MemoryBlockTypes and use these identifiers in protocol.
+        https://bugs.webkit.org/show_bug.cgi?id=95957
+
+        Reviewed by Yury Semikhatsky.
+
+        Now when we use string identifiers as MemoryObjectType we can use them as the identifiers for the protocol
+        instead of MemoryBlockNames hardcoded in InspectorMemoryAgent..
+        At a later stage, when each memory type is counted in MemoryInstrumentation
+        we will build the blocks hierarchy for the front-end automatically.
+
+        * tests/MemoryInstrumentationTest.cpp:
+        (WebCore::InstrumentedUndefined::InstrumentedUndefined):
+        (WebCore::InstrumentedUndefined::reportMemoryUsage):
+        (WebCore::InstrumentedDOM::InstrumentedDOM):
+        (WebCore::InstrumentedDOM::reportMemoryUsage):
+        (InstrumentedDOM):
+        (WebCore::TEST):
+
 2012-09-06  Kenichi Ishibashi  <bashi@chromium.org>
 

trunk/Source/WebKit/chromium/tests/MemoryInstrumentationTest.cpp

@@ -173 +173 @@
 }
 
-class InstrumentedOther {
-public:
-    InstrumentedOther() : m_data(0) { }
+class InstrumentedUndefined {
+public:
+    InstrumentedUndefined() : m_data(0) { }
 
     void reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
     {
-        MemoryClassInfo info(memoryObjectInfo, this, GenericMemoryTypes::Other);
+        MemoryClassInfo info(memoryObjectInfo, this, GenericMemoryTypes::Undefined);
     }
     int m_data;
@@ -186 +186 @@
 class InstrumentedDOM {
 public:
-    InstrumentedDOM() : m_instrumentedOther(adoptPtr(new InstrumentedOther)) { }
+    InstrumentedDOM() : m_instrumentedUndefined(adoptPtr(new InstrumentedUndefined)) { }
 
     void reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
     {
         MemoryClassInfo info(memoryObjectInfo, this, WebCoreMemoryTypes::DOM);
-        info.addInstrumentedMember(m_instrumentedOther);
-    }
-    OwnPtr<InstrumentedOther> m_instrumentedOther;
+        info.addInstrumentedMember(m_instrumentedUndefined);
+    }
+    OwnPtr<InstrumentedUndefined> m_instrumentedUndefined;
 };
 
@@ -202 +202 @@
     OwnPtr<InstrumentedDOM> instrumentedDOM(adoptPtr(new InstrumentedDOM));
     impl.addRootObject(instrumentedDOM);
-    EXPECT_EQ(sizeof(InstrumentedDOM) + sizeof(InstrumentedOther), impl.reportedSizeForAllTypes());
-    EXPECT_EQ(sizeof(InstrumentedDOM) + sizeof(InstrumentedOther), impl.totalSize(WebCoreMemoryTypes::DOM));
+    EXPECT_EQ(sizeof(InstrumentedDOM) + sizeof(InstrumentedUndefined), impl.reportedSizeForAllTypes());
+    EXPECT_EQ(sizeof(InstrumentedDOM) + sizeof(InstrumentedUndefined), impl.totalSize(WebCoreMemoryTypes::DOM));
     EXPECT_EQ(2, visitedObjects.size());
 }