Revision: 10495
Author: [email protected]
Date: Wed Jan 25 00:50:55 2012
Log: Do not follow accessor map transitions when marking descriptor
arrays.
Note that we currently have no such transitions, but we will in the future,
and
we have to avoid keeping maps live too long.
Review URL: https://chromiumcodereview.appspot.com/9212045
http://code.google.com/p/v8/source/detail?r=10495
Modified:
/branches/bleeding_edge/src/mark-compact-inl.h
/branches/bleeding_edge/src/mark-compact.cc
/branches/bleeding_edge/src/mark-compact.h
=======================================
--- /branches/bleeding_edge/src/mark-compact-inl.h Thu Jan 19 05:22:16 2012
+++ /branches/bleeding_edge/src/mark-compact-inl.h Wed Jan 25 00:50:55 2012
@@ -64,6 +64,19 @@
ProcessNewlyMarkedObject(obj);
}
}
+
+
+bool MarkCompactCollector::MarkObjectWithoutPush(HeapObject* object) {
+ MarkBit mark = Marking::MarkBitFrom(object);
+ bool old_mark = mark.Get();
+ if (!old_mark) SetMark(object, mark);
+ return old_mark;
+}
+
+
+void MarkCompactCollector::MarkObjectAndPush(HeapObject* object) {
+ if (!MarkObjectWithoutPush(object)) marking_deque_.PushBlack(object);
+}
void MarkCompactCollector::SetMark(HeapObject* obj, MarkBit mark_bit) {
=======================================
--- /branches/bleeding_edge/src/mark-compact.cc Thu Jan 19 10:50:01 2012
+++ /branches/bleeding_edge/src/mark-compact.cc Wed Jan 25 00:50:55 2012
@@ -1670,6 +1670,16 @@
StaticMarkingVisitor::VisitPointers(map->GetHeap(), start_slot,
end_slot);
}
+
+
+void MarkCompactCollector::MarkAccessorPairSlot(HeapObject* accessors,
+ int offset) {
+ Object** slot = HeapObject::RawField(accessors, offset);
+ HeapObject* accessor = HeapObject::cast(*slot);
+ if (accessor->IsMap()) return;
+ RecordSlot(slot, slot, accessor);
+ MarkObjectAndPush(accessor);
+}
void MarkCompactCollector::MarkDescriptorArray(
@@ -1699,27 +1709,37 @@
PropertyDetails details(Smi::cast(contents->get(i + 1)));
Object** slot = contents->data_start() + i;
- Object* value = *slot;
- if (!value->IsHeapObject()) continue;
+ if (!(*slot)->IsHeapObject()) continue;
+ HeapObject* value = HeapObject::cast(*slot);
RecordSlot(slot, slot, *slot);
- if (details.IsProperty()) {
- HeapObject* object = HeapObject::cast(value);
- MarkBit mark = Marking::MarkBitFrom(HeapObject::cast(object));
- if (!mark.Get()) {
- SetMark(HeapObject::cast(object), mark);
- marking_deque_.PushBlack(object);
- }
- } else if (details.type() == ELEMENTS_TRANSITION &&
value->IsFixedArray()) {
- // For maps with multiple elements transitions, the transition maps
are
- // stored in a FixedArray. Keep the fixed array alive but not the
maps
- // that it refers to.
- HeapObject* object = HeapObject::cast(value);
- MarkBit mark = Marking::MarkBitFrom(HeapObject::cast(object));
- if (!mark.Get()) {
- SetMark(HeapObject::cast(object), mark);
- }
+ switch (details.type()) {
+ case NORMAL:
+ case FIELD:
+ case CONSTANT_FUNCTION:
+ case HANDLER:
+ case INTERCEPTOR:
+ MarkObjectAndPush(value);
+ break;
+ case CALLBACKS:
+ if (!value->IsAccessorPair()) {
+ MarkObjectAndPush(value);
+ } else if (!MarkObjectWithoutPush(value)) {
+ MarkAccessorPairSlot(value, AccessorPair::kGetterOffset);
+ MarkAccessorPairSlot(value, AccessorPair::kSetterOffset);
+ }
+ break;
+ case ELEMENTS_TRANSITION:
+ // For maps with multiple elements transitions, the transition
maps are
+ // stored in a FixedArray. Keep the fixed array alive but not the
maps
+ // that it refers to.
+ if (value->IsFixedArray()) MarkObjectWithoutPush(value);
+ break;
+ case MAP_TRANSITION:
+ case CONSTANT_TRANSITION:
+ case NULL_DESCRIPTOR:
+ break;
}
}
// The DescriptorArray descriptors contains a pointer to its contents
array,
=======================================
--- /branches/bleeding_edge/src/mark-compact.h Thu Jan 19 05:22:16 2012
+++ /branches/bleeding_edge/src/mark-compact.h Wed Jan 25 00:50:55 2012
@@ -628,6 +628,9 @@
// This is for non-incremental marking.
INLINE(void MarkObject(HeapObject* obj, MarkBit mark_bit));
+ INLINE(bool MarkObjectWithoutPush(HeapObject* object));
+ INLINE(void MarkObjectAndPush(HeapObject* value));
+
// Marks the object black. This is for non-incremental marking.
INLINE(void SetMark(HeapObject* obj, MarkBit mark_bit));
@@ -645,6 +648,7 @@
// Mark a Map and its DescriptorArray together, skipping transitions.
void MarkMapContents(Map* map);
+ void MarkAccessorPairSlot(HeapObject* accessors, int offset);
void MarkDescriptorArray(DescriptorArray* descriptors);
// Mark the heap roots and all objects reachable from them.
--
v8-dev mailing list
[email protected]
http://groups.google.com/group/v8-dev
