Changeset 41443 in webkit for trunk/JavaScriptCore/wtf/TCPageMap.h

Timestamp:

Mar 4, 2009, 10:04:18 PM (16 years ago)

Author:

[email protected]

Message:

<rdar://problem/6354858> FastMallocZone's enumeration code reports fragmented administration space

Reviewed by Oliver Hunt.

The handling of MALLOC_ADMIN_REGION_RANGE_TYPE in FastMalloc's zone was incorrect. It was attempting
to record the memory containing and individual span as an administrative region, when all memory
allocated via MetaDataAlloc should in fact be recorded. This was causing memory regions allocated
via MetaDataAlloc to appear as "VM_ALLOCATE ?" in vmmap output. They are now correctly reported as
"MALLOC_OTHER" regions associated with the JavaScriptCore FastMalloc zone.

Memory is allocated via MetaDataAlloc from two locations: PageHeapAllocator, and TCMalloc_PageMap{2,3}.
These two cases are handled differently.

PageHeapAllocator is extended to keep a linked list of memory regions that it has allocated. The
first object in an allocated region contains the link to the previously allocated region. To record
the administrative regions of a PageHeapAllocator we can simply walk the linked list and record
each allocated region we encounter.

TCMalloc_PageMaps allocate memory via MetaDataAlloc to store each level of the radix tree. To record
the administrative regions of a TCMalloc_PageMap we walk the tree and record the storage used for nodes
at each position rather than the nodes themselves.

A small performance improvement is achieved by coalescing adjacent memory regions inside the PageMapMemoryUsageRecorder
so that fewer calls in to the range recorder are necessary. We further reduce the number of calls to the
range recorder by aggregating the in-use ranges of a given memory region into a local buffer before recording
them with a single call. A similar approach is also used by AdminRegionRecorder.

• wtf/FastMalloc.cpp:

(WTF::PageHeapAllocator::Init):
(WTF::PageHeapAllocator::New):
(WTF::PageHeapAllocator::recordAdministrativeRegions):
(WTF::TCMallocStats::FreeObjectFinder::isFreeObject):
(WTF::TCMallocStats::PageMapMemoryUsageRecorder::~PageMapMemoryUsageRecorder):
(WTF::TCMallocStats::PageMapMemoryUsageRecorder::recordPendingRegions):
(WTF::TCMallocStats::PageMapMemoryUsageRecorder::visit):
(WTF::TCMallocStats::AdminRegionRecorder::AdminRegionRecorder):
(WTF::TCMallocStats::AdminRegionRecorder::recordRegion):
(WTF::TCMallocStats::AdminRegionRecorder::visit):
(WTF::TCMallocStats::AdminRegionRecorder::recordPendingRegions):
(WTF::TCMallocStats::AdminRegionRecorder::~AdminRegionRecorder):
(WTF::TCMallocStats::FastMallocZone::enumerate):
(WTF::TCMallocStats::FastMallocZone::FastMallocZone):
(WTF::TCMallocStats::FastMallocZone::init):

• wtf/TCPageMap.h:

(TCMalloc_PageMap2::visitValues):
(TCMalloc_PageMap2::visitAllocations):
(TCMalloc_PageMap3::visitValues):
(TCMalloc_PageMap3::visitAllocations):

File:

• trunk/JavaScriptCore/wtf/TCPageMap.h (modified) (5 diffs)

trunk/JavaScriptCore/wtf/TCPageMap.h

@@ -55 +55 @@
 
 #include <string.h>
-
 #include "Assertions.h"
 
@@ -165 +164 @@
 #ifdef WTF_CHANGES
   template<class Visitor, class MemoryReader>
-  void visit(const Visitor& visitor, const MemoryReader& reader)
+  void visitValues(Visitor& visitor, const MemoryReader& reader)
   {
     for (int i = 0; i < ROOT_LENGTH; i++) {
@@ -174 +173 @@
       for (int j = 0; j < LEAF_LENGTH; j += visitor.visit(l->values[j]))
         ;
+    }
+  }
+
+  template<class Visitor, class MemoryReader>
+  void visitAllocations(Visitor& visitor, const MemoryReader&) {
+    for (int i = 0; i < ROOT_LENGTH; i++) {
+      if (root_[i])
+        visitor.visit(root_[i], sizeof(Leaf));
     }
   }
@@ -267 +274 @@
 #ifdef WTF_CHANGES
   template<class Visitor, class MemoryReader>
-  void visit(const Visitor& visitor, const MemoryReader& reader) {
+  void visitValues(Visitor& visitor, const MemoryReader& reader) {
     Node* root = reader(root_);
     for (int i = 0; i < INTERIOR_LENGTH; i++) {
@@ -284 +291 @@
     }
   }
+
+  template<class Visitor, class MemoryReader>
+  void visitAllocations(Visitor& visitor, const MemoryReader& reader) {
+    visitor.visit(root_, sizeof(Node));
+
+    Node* root = reader(root_);
+    for (int i = 0; i < INTERIOR_LENGTH; i++) {
+      if (!root->ptrs[i])
+        continue;
+
+      visitor.visit(root->ptrs[i], sizeof(Node));
+      Node* n = reader(root->ptrs[i]);
+      for (int j = 0; j < INTERIOR_LENGTH; j++) {
+        if (!n->ptrs[j])
+          continue;
+
+        visitor.visit(n->ptrs[j], sizeof(Leaf));
+      }
+    }
+  }
 #endif
 };