Revision: 8937
Author: [email protected]
Date: Tue Aug 16 01:56:33 2011
Log: Avoid some crashes when running without snapshots.
Make many more tests succeede with snapshots off.
Review URL: http://codereview.chromium.org/7650010
http://code.google.com/p/v8/source/detail?r=8937
Modified:
/branches/experimental/gc/src/debug.cc
/branches/experimental/gc/src/heap.cc
/branches/experimental/gc/src/heap.h
/branches/experimental/gc/src/liveedit.cc
/branches/experimental/gc/src/log.cc
/branches/experimental/gc/src/objects.h
/branches/experimental/gc/src/profile-generator.cc
/branches/experimental/gc/src/profile-generator.h
/branches/experimental/gc/src/runtime.cc
/branches/experimental/gc/src/spaces.cc
/branches/experimental/gc/test/cctest/test-api.cc
/branches/experimental/gc/test/cctest/test-debug.cc
/branches/experimental/gc/test/cctest/test-heap.cc
=======================================
--- /branches/experimental/gc/src/debug.cc Wed Aug 10 05:50:30 2011
+++ /branches/experimental/gc/src/debug.cc Tue Aug 16 01:56:33 2011
@@ -1913,7 +1913,7 @@
HeapIterator iterator;
AssertNoAllocation no_allocation;
- for (HeapObject* obj = iterator.Next(); obj != NULL; obj =
iterator.Next()) {
+ for (HeapObject* obj = iterator.next(); obj != NULL; obj =
iterator.next()) {
if (obj->IsScript() && Script::cast(obj)->HasValidSource()) {
script_cache_->Add(Handle<Script>(Script::cast(obj)));
count++;
=======================================
--- /branches/experimental/gc/src/heap.cc Fri Aug 12 02:21:47 2011
+++ /branches/experimental/gc/src/heap.cc Tue Aug 16 01:56:33 2011
@@ -224,7 +224,10 @@
int Heap::GcSafeSizeOfOldObject(HeapObject* object) {
- return object->Size();
+ if (IntrusiveMarking::IsMarked(object)) {
+ return IntrusiveMarking::SizeOfMarkedObject(object);
+ }
+ return object->SizeFromMap(object->map());
}
@@ -4115,16 +4118,20 @@
Struct::cast(result)->InitializeBody(size);
return result;
}
+
+
+bool Heap::IsHeapIterable() {
+ return (!old_pointer_space()->was_swept_conservatively() &&
+ !old_data_space()->was_swept_conservatively());
+}
void Heap::EnsureHeapIsIterable() {
ASSERT(IsAllocationAllowed());
- if (old_pointer_space()->was_swept_conservatively() ||
- old_data_space()->was_swept_conservatively()) {
+ if (!IsHeapIterable()) {
CollectAllGarbage(kMakeHeapIterableMask);
}
- ASSERT(!old_pointer_space()->was_swept_conservatively());
- ASSERT(!old_data_space()->was_swept_conservatively());
+ ASSERT(IsHeapIterable());
}
@@ -4341,6 +4348,7 @@
lo_space_->Verify();
}
+
#endif // DEBUG
@@ -4825,9 +4833,9 @@
isolate()->memory_allocator()->Available();
if (take_snapshot) {
HeapIterator iterator;
- for (HeapObject* obj = iterator.Next();
+ for (HeapObject* obj = iterator.next();
obj != NULL;
- obj = iterator.Next()) {
+ obj = iterator.next()) {
InstanceType type = obj->map()->instance_type();
ASSERT(0 <= type && type <= LAST_TYPE);
stats->objects_per_type[type]++;
@@ -5464,9 +5472,9 @@
void MarkUnreachableObjects() {
HeapIterator iterator;
- for (HeapObject* obj = iterator.Next();
+ for (HeapObject* obj = iterator.next();
obj != NULL;
- obj = iterator.Next()) {
+ obj = iterator.next()) {
IntrusiveMarking::SetMark(obj);
}
UnmarkingVisitor visitor;
@@ -5479,9 +5487,18 @@
};
-HeapIterator::HeapIterator() {
+HeapIterator::HeapIterator()
+ : filtering_(HeapIterator::kNoFiltering),
+ filter_(NULL) {
Init();
}
+
+
+HeapIterator::HeapIterator(HeapIterator::HeapObjectsFiltering filtering)
+ : filtering_(filtering),
+ filter_(NULL) {
+ Init();
+}
HeapIterator::~HeapIterator() {
@@ -5491,21 +5508,50 @@
void HeapIterator::Init() {
// Start the iteration.
- HEAP->EnsureHeapIsIterable();
- space_iterator_ = new SpaceIterator();
+ space_iterator_ = filtering_ == kNoFiltering ? new SpaceIterator :
+ new SpaceIterator(Isolate::Current()->heap()->
+ GcSafeSizeOfOldObjectFunction());
+ switch (filtering_) {
+ case kFilterFreeListNodes:
+ // TODO(gc): Not handled.
+ break;
+ case kFilterUnreachable:
+ filter_ = new UnreachableObjectsFilter;
+ break;
+ default:
+ break;
+ }
object_iterator_ = space_iterator_->next();
}
void HeapIterator::Shutdown() {
+#ifdef DEBUG
+ // Assert that in filtering mode we have iterated through all
+ // objects. Otherwise, heap will be left in an inconsistent state.
+ if (filtering_ != kNoFiltering) {
+ ASSERT(object_iterator_ == NULL);
+ }
+#endif
// Make sure the last iterator is deallocated.
delete space_iterator_;
space_iterator_ = NULL;
object_iterator_ = NULL;
+ delete filter_;
+ filter_ = NULL;
}
-HeapObject* HeapIterator::Next() {
+HeapObject* HeapIterator::next() {
+ if (filter_ == NULL) return NextObject();
+
+ HeapObject* obj = NextObject();
+ while (obj != NULL && filter_->SkipObject(obj)) obj = NextObject();
+ return obj;
+}
+
+
+HeapObject* HeapIterator::NextObject() {
// No iterator means we are done.
if (object_iterator_ == NULL) return NULL;
@@ -5527,7 +5573,7 @@
}
-void HeapIterator::Reset() {
+void HeapIterator::reset() {
// Restart the iterator.
Shutdown();
Init();
=======================================
--- /branches/experimental/gc/src/heap.h Fri Aug 12 02:21:47 2011
+++ /branches/experimental/gc/src/heap.h Tue Aug 16 01:56:33 2011
@@ -913,6 +913,9 @@
// state where we can iterate over the heap visiting all objects.
void CollectAllGarbage(int flags);
+ // Check whether the heap is currently iterable.
+ bool IsHeapIterable();
+
// Ensure that we have swept all spaces in such a way that we can iterate
// over all objects. May cause a GC.
void EnsureHeapIsIterable();
@@ -1929,8 +1932,7 @@
// A HeapIterator provides iteration over the whole heap. It
// aggregates the specific iterators for the different spaces as
-// these can only iterate over one space only. It can only be guaranteed
-// to iterate over live objects.
+// these can only iterate over one space only.
//
// HeapIterator can skip free list nodes (that is, de-allocated heap
// objects that still remain in the heap). As implementation of free
@@ -1941,18 +1943,28 @@
class HeapIterator BASE_EMBEDDED {
public:
+ enum HeapObjectsFiltering {
+ kNoFiltering,
+ kFilterFreeListNodes,
+ kFilterUnreachable
+ };
+
HeapIterator();
+ explicit HeapIterator(HeapObjectsFiltering filtering);
~HeapIterator();
- HeapObject* Next();
- void Reset();
+ HeapObject* next();
+ void reset();
private:
// Perform the initialization.
void Init();
// Perform all necessary shutdown (destruction) work.
void Shutdown();
-
+ HeapObject* NextObject();
+
+ HeapObjectsFiltering filtering_;
+ HeapObjectsFilter* filter_;
// Space iterator for iterating all the spaces.
SpaceIterator* space_iterator_;
// Object iterator for the space currently being iterated.
@@ -2355,10 +2367,13 @@
ASSERT(IsMarked(object));
}
- static int SizeOfMarkedObject(HeapObject* object) {
+ static Map* MapOfMarkedObject(HeapObject* object) {
uintptr_t map_word = object->map_word().ToRawValue();
- Map* map = MapWord::FromRawValue(map_word | kNotMarkedBit).ToMap();
- return object->SizeFromMap(map);
+ return MapWord::FromRawValue(map_word | kNotMarkedBit).ToMap();
+ }
+
+ static int SizeOfMarkedObject(HeapObject* object) {
+ return object->SizeFromMap(MapOfMarkedObject(object));
}
private:
=======================================
--- /branches/experimental/gc/src/liveedit.cc Tue Jul 12 16:04:25 2011
+++ /branches/experimental/gc/src/liveedit.cc Tue Aug 16 01:56:33 2011
@@ -1022,7 +1022,7 @@
// Now iterate over all pointers of all objects, including code_target
// implicit pointers.
- for (HeapObject* obj = iterator.Next(); obj != NULL; obj =
iterator.Next()) {
+ for (HeapObject* obj = iterator.next(); obj != NULL; obj =
iterator.next()) {
obj->Iterate(&visitor);
}
=======================================
--- /branches/experimental/gc/src/log.cc Wed Aug 3 09:10:10 2011
+++ /branches/experimental/gc/src/log.cc Tue Aug 16 01:56:33 2011
@@ -1362,7 +1362,7 @@
// Iterate the heap to find shared function info objects and record
// the unoptimized code for them.
- for (HeapObject* obj = iterator.Next(); obj != NULL; obj =
iterator.Next()) {
+ for (HeapObject* obj = iterator.next(); obj != NULL; obj =
iterator.next()) {
if (!obj->IsSharedFunctionInfo()) continue;
SharedFunctionInfo* sfi = SharedFunctionInfo::cast(obj);
if (sfi->is_compiled()
@@ -1521,7 +1521,7 @@
void Logger::LogCodeObjects() {
HeapIterator iterator;
AssertNoAllocation no_alloc;
- for (HeapObject* obj = iterator.Next(); obj != NULL; obj =
iterator.Next()) {
+ for (HeapObject* obj = iterator.next(); obj != NULL; obj =
iterator.next()) {
if (obj->IsCode()) LogCodeObject(obj);
}
}
@@ -1589,7 +1589,7 @@
void Logger::LogAccessorCallbacks() {
HeapIterator iterator;
AssertNoAllocation no_alloc;
- for (HeapObject* obj = iterator.Next(); obj != NULL; obj =
iterator.Next()) {
+ for (HeapObject* obj = iterator.next(); obj != NULL; obj =
iterator.next()) {
if (!obj->IsAccessorInfo()) continue;
AccessorInfo* ai = AccessorInfo::cast(obj);
if (!ai->name()->IsString()) continue;
=======================================
--- /branches/experimental/gc/src/objects.h Wed Aug 10 05:50:30 2011
+++ /branches/experimental/gc/src/objects.h Tue Aug 16 01:56:33 2011
@@ -1130,18 +1130,14 @@
HeapObjectPrint(stdout);
}
void HeapObjectPrint(FILE* out);
+ void PrintHeader(FILE* out, const char* id);
#endif
+
#ifdef DEBUG
void HeapObjectVerify();
inline void VerifyObjectField(int offset);
inline void VerifySmiField(int offset);
-#endif
-
-#ifdef OBJECT_PRINT
- void PrintHeader(FILE* out, const char* id);
-#endif
-
-#ifdef DEBUG
+
// Verify a pointer is a valid HeapObject pointer that points to object
// areas in the heap.
static void VerifyHeapPointer(Object* p);
=======================================
--- /branches/experimental/gc/src/profile-generator.cc Wed Aug 3 09:10:10
2011
+++ /branches/experimental/gc/src/profile-generator.cc Tue Aug 16 01:56:33
2011
@@ -1786,9 +1786,11 @@
int V8HeapExplorer::EstimateObjectsCount(HeapIterator* iterator) {
int objects_count = 0;
- for (HeapObject* obj = iterator->Next();
+ for (HeapObject* obj = iterator->next();
obj != NULL;
- obj = iterator->Next(), ++objects_count) {}
+ obj = iterator->next()) {
+ objects_count++;
+ }
return objects_count;
}
@@ -2128,15 +2130,16 @@
bool V8HeapExplorer::IterateAndExtractReferences(
- HeapIterator* iterator,
SnapshotFillerInterface* filler) {
+ HeapIterator iterator(HeapIterator::kFilterUnreachable);
+
filler_ = filler;
bool interrupted = false;
// Heap iteration with filtering must be finished in any case.
- for (HeapObject* obj = iterator->Next();
+ for (HeapObject* obj = iterator.next();
obj != NULL;
- obj = iterator->Next(), progress_->ProgressStep()) {
+ obj = iterator.next(), progress_->ProgressStep()) {
if (!interrupted) {
ExtractReferences(obj);
if (!progress_->ProgressReport(false)) interrupted = true;
@@ -2705,18 +2708,35 @@
Isolate::Current()->heap()->CollectAllGarbage(Heap::kMakeHeapIterableMask);
Isolate::Current()->heap()->CollectAllGarbage(Heap::kMakeHeapIterableMask);
- // Iterator creation should follow TagGlobalObjects as it can allocate.
- HeapIterator set_progress_heap_iterator;
- HeapIterator count_entries_heap_iterator;
- HeapIterator fill_references_heap_iterator;
-
+#ifdef DEBUG
+ Heap* debug_heap = Isolate::Current()->heap();
+ ASSERT(!debug_heap->old_data_space()->was_swept_conservatively());
+ ASSERT(!debug_heap->old_pointer_space()->was_swept_conservatively());
+ ASSERT(!debug_heap->code_space()->was_swept_conservatively());
+ ASSERT(!debug_heap->cell_space()->was_swept_conservatively());
+ ASSERT(!debug_heap->map_space()->was_swept_conservatively());
+#endif
+
+ // The following code uses heap iterators, so we want the heap to be
+ // stable. It should follow TagGlobalObjects as that can allocate.
AssertNoAllocation no_alloc;
- SetProgressTotal(&set_progress_heap_iterator,
- 4); // 2 passes + dominators + sizes.
+#ifdef DEBUG
+ debug_heap->Verify();
+#endif
+
+ SetProgressTotal(4); // 2 passes + dominators + sizes.
+
+#ifdef DEBUG
+ debug_heap->Verify();
+#endif
// Pass 1. Iterate heap contents to count entries and references.
- if (!CountEntriesAndReferences(&count_entries_heap_iterator)) return
false;
+ if (!CountEntriesAndReferences()) return false;
+
+#ifdef DEBUG
+ debug_heap->Verify();
+#endif
// Allocate and fill entries in the snapshot, allocate references.
snapshot_->AllocateEntries(entries_.entries_count(),
@@ -2725,7 +2745,7 @@
entries_.AllocateEntries();
// Pass 2. Fill references.
- if (!FillReferences(&fill_references_heap_iterator)) return false;
+ if (!FillReferences()) return false;
if (!SetEntriesDominators()) return false;
if (!ApproximateRetainedSizes()) return false;
@@ -2753,30 +2773,30 @@
}
-void HeapSnapshotGenerator::SetProgressTotal(HeapIterator* iterator,
- int iterations_count) {
+void HeapSnapshotGenerator::SetProgressTotal(int iterations_count) {
if (control_ == NULL) return;
+ HeapIterator iterator(HeapIterator::kFilterUnreachable);
progress_total_ = (
- v8_heap_explorer_.EstimateObjectsCount(iterator) +
+ v8_heap_explorer_.EstimateObjectsCount(&iterator) +
dom_explorer_.EstimateObjectsCount()) * iterations_count;
progress_counter_ = 0;
}
-bool HeapSnapshotGenerator::CountEntriesAndReferences(HeapIterator*
iterator) {
+bool HeapSnapshotGenerator::CountEntriesAndReferences() {
SnapshotCounter counter(&entries_);
v8_heap_explorer_.AddRootEntries(&counter);
dom_explorer_.AddRootEntries(&counter);
return
- v8_heap_explorer_.IterateAndExtractReferences(iterator, &counter) &&
+ v8_heap_explorer_.IterateAndExtractReferences(&counter) &&
dom_explorer_.IterateAndExtractReferences(&counter);
}
-bool HeapSnapshotGenerator::FillReferences(HeapIterator* iterator) {
+bool HeapSnapshotGenerator::FillReferences() {
SnapshotFiller filler(snapshot_, &entries_);
return
- v8_heap_explorer_.IterateAndExtractReferences(iterator, &filler) &&
+ v8_heap_explorer_.IterateAndExtractReferences(&filler) &&
dom_explorer_.IterateAndExtractReferences(&filler);
}
@@ -2807,7 +2827,7 @@
nodes_to_visit.RemoveLast();
}
}
- entries->Truncate(current_entry);
+ ASSERT_EQ(current_entry, entries->length());
}
=======================================
--- /branches/experimental/gc/src/profile-generator.h Wed Aug 3 09:10:10
2011
+++ /branches/experimental/gc/src/profile-generator.h Tue Aug 16 01:56:33
2011
@@ -1,4 +1,4 @@
-// Copyright 2010 the V8 project authors. All rights reserved.
+// Copyright 2011 the V8 project authors. All rights reserved.
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
@@ -921,8 +921,7 @@
HeapThing ptr, int children_count, int retainers_count);
void AddRootEntries(SnapshotFillerInterface* filler);
int EstimateObjectsCount(HeapIterator* iterator);
- bool IterateAndExtractReferences(HeapIterator* iterator,
- SnapshotFillerInterface* filler);
+ bool IterateAndExtractReferences(SnapshotFillerInterface* filler);
void TagGlobalObjects();
static HeapObject* const kInternalRootObject;
@@ -1053,13 +1052,13 @@
bool ApproximateRetainedSizes();
bool BuildDominatorTree(const Vector<HeapEntry*>& entries,
Vector<HeapEntry*>* dominators);
- bool CountEntriesAndReferences(HeapIterator* iterator);
- bool FillReferences(HeapIterator* iterator);
+ bool CountEntriesAndReferences();
+ bool FillReferences();
void FillReversePostorderIndexes(Vector<HeapEntry*>* entries);
void ProgressStep();
bool ProgressReport(bool force = false);
bool SetEntriesDominators();
- void SetProgressTotal(HeapIterator* iterator, int iterations_count);
+ void SetProgressTotal(int iterations_count);
HeapSnapshot* snapshot_;
v8::ActivityControl* control_;
=======================================
--- /branches/experimental/gc/src/runtime.cc Wed Aug 10 05:50:30 2011
+++ /branches/experimental/gc/src/runtime.cc Tue Aug 16 01:56:33 2011
@@ -11086,10 +11086,11 @@
Handle<SharedFunctionInfo> target;
while (!done) {
{ // Extra scope for iterator and no-allocation.
- HeapIterator iterator;
+ isolate->heap()->EnsureHeapIsIterable();
AssertNoAllocation no_alloc_during_heap_iteration;
- for (HeapObject* obj = iterator.Next();
- obj != NULL; obj = iterator.Next()) {
+ HeapIterator iterator;
+ for (HeapObject* obj = iterator.next();
+ obj != NULL; obj = iterator.next()) {
if (obj->IsSharedFunctionInfo()) {
Handle<SharedFunctionInfo> shared(SharedFunctionInfo::cast(obj));
if (shared->script() == *script) {
@@ -11629,7 +11630,7 @@
int count = 0;
JSObject* last = NULL;
HeapObject* heap_obj = NULL;
- while (((heap_obj = iterator->Next()) != NULL) &&
+ while (((heap_obj = iterator->next()) != NULL) &&
(max_references == 0 || count < max_references)) {
// Only look at all JSObjects.
if (heap_obj->IsJSObject()) {
@@ -11699,8 +11700,6 @@
// Due to the GC above we know it won't need to do that, but it seems
cleaner
// to get the heap iterator constructed before we start having
unprotected
// Object* locals that are not protected by handles.
- HeapIterator heap_iterator;
- HeapIterator heap_iterator2;
// Check parameters.
CONVERT_CHECKED(JSObject, target, args[0]);
@@ -11719,6 +11718,7 @@
// Get the number of referencing objects.
int count;
+ HeapIterator heap_iterator;
count = DebugReferencedBy(&heap_iterator,
target, instance_filter, max_references,
NULL, 0, arguments_function);
@@ -11731,6 +11731,9 @@
FixedArray* instances = FixedArray::cast(object);
// Fill the referencing objects.
+ // AllocateFixedArray above does not make the heap non-iterable.
+ ASSERT(HEAP->IsHeapIterable());
+ HeapIterator heap_iterator2;
count = DebugReferencedBy(&heap_iterator2,
target, instance_filter, max_references,
instances, count, arguments_function);
@@ -11757,7 +11760,7 @@
// Iterate the heap.
int count = 0;
HeapObject* heap_obj = NULL;
- while (((heap_obj = iterator->Next()) != NULL) &&
+ while (((heap_obj = iterator->next()) != NULL) &&
(max_references == 0 || count < max_references)) {
// Only look at all JSObjects.
if (heap_obj->IsJSObject()) {
@@ -11787,9 +11790,6 @@
// First perform a full GC in order to avoid dead objects.
isolate->heap()->CollectAllGarbage(Heap::kMakeHeapIterableMask);
- HeapIterator heap_iterator;
- HeapIterator heap_iterator2;
-
// Check parameters.
CONVERT_CHECKED(JSFunction, constructor, args[0]);
CONVERT_NUMBER_CHECKED(int32_t, max_references, Int32, args[1]);
@@ -11797,6 +11797,7 @@
// Get the number of referencing objects.
int count;
+ HeapIterator heap_iterator;
count = DebugConstructedBy(&heap_iterator,
constructor,
max_references,
@@ -11810,7 +11811,9 @@
}
FixedArray* instances = FixedArray::cast(object);
+ ASSERT(HEAP->IsHeapIterable());
// Fill the referencing objects.
+ HeapIterator heap_iterator2;
count = DebugConstructedBy(&heap_iterator2,
constructor,
max_references,
@@ -11894,9 +11897,9 @@
AssertNoAllocation no_allocations;
int counter = 0;
int buffer_size = buffer->length();
- for (HeapObject* obj = iterator->Next();
+ for (HeapObject* obj = iterator->next();
obj != NULL;
- obj = iterator->Next()) {
+ obj = iterator->next()) {
ASSERT(obj != NULL);
if (!obj->IsSharedFunctionInfo()) {
continue;
@@ -11931,16 +11934,18 @@
array = isolate->factory()->NewFixedArray(kBufferSize);
int number;
{
- HeapIterator heap_iterator;
+ isolate->heap()->EnsureHeapIsIterable();
AssertNoAllocation no_allocations;
+ HeapIterator heap_iterator;
Script* scr = *script;
FixedArray* arr = *array;
number = FindSharedFunctionInfosForScript(&heap_iterator, scr, arr);
}
if (number > kBufferSize) {
array = isolate->factory()->NewFixedArray(number);
- HeapIterator heap_iterator;
+ isolate->heap()->EnsureHeapIsIterable();
AssertNoAllocation no_allocations;
+ HeapIterator heap_iterator;
Script* scr = *script;
FixedArray* arr = *array;
FindSharedFunctionInfosForScript(&heap_iterator, scr, arr);
@@ -12424,10 +12429,11 @@
// Scan the heap for Script objects to find the script with the requested
// script data.
Handle<Script> script;
- HeapIterator iterator;
+ script_name->GetHeap()->EnsureHeapIsIterable();
AssertNoAllocation no_allocation_during_heap_iteration;
+ HeapIterator iterator;
HeapObject* obj = NULL;
- while (script.is_null() && ((obj = iterator.Next()) != NULL)) {
+ while (script.is_null() && ((obj = iterator.next()) != NULL)) {
// If a script is found check if it has the script data requested.
if (obj->IsScript()) {
if (Script::cast(obj)->name()->IsString()) {
=======================================
--- /branches/experimental/gc/src/spaces.cc Fri Aug 12 02:21:47 2011
+++ /branches/experimental/gc/src/spaces.cc Tue Aug 16 01:56:33 2011
@@ -35,6 +35,7 @@
namespace v8 {
namespace internal {
+
//
----------------------------------------------------------------------------
// HeapObjectIterator
=======================================
--- /branches/experimental/gc/test/cctest/test-api.cc Thu Aug 11 05:35:11
2011
+++ /branches/experimental/gc/test/cctest/test-api.cc Tue Aug 16 01:56:33
2011
@@ -9864,7 +9864,7 @@
i::Isolate::Current()->heap()->EnsureHeapIsIterable();
int count = 0;
i::HeapIterator it;
- for (i::HeapObject* object = it.Next(); object != NULL; object =
it.Next())
+ for (i::HeapObject* object = it.next(); object != NULL; object =
it.next())
if (object->IsJSGlobalObject()) count++;
return count;
}
=======================================
--- /branches/experimental/gc/test/cctest/test-debug.cc Wed Aug 10 05:50:30
2011
+++ /branches/experimental/gc/test/cctest/test-debug.cc Tue Aug 16 01:56:33
2011
@@ -429,7 +429,7 @@
// Iterate the head and check that there are no debugger related objects
left.
HeapIterator iterator;
- for (HeapObject* obj = iterator.Next(); obj != NULL; obj =
iterator.Next()) {
+ for (HeapObject* obj = iterator.next(); obj != NULL; obj =
iterator.next()) {
CHECK(!obj->IsDebugInfo());
CHECK(!obj->IsBreakPointInfo());
=======================================
--- /branches/experimental/gc/test/cctest/test-heap.cc Wed Aug 10 05:50:30
2011
+++ /branches/experimental/gc/test/cctest/test-heap.cc Tue Aug 16 01:56:33
2011
@@ -791,7 +791,7 @@
// Count the number of objects found in the heap.
int found_count = 0;
HeapIterator iterator;
- for (HeapObject* obj = iterator.Next(); obj != NULL; obj =
iterator.Next()) {
+ for (HeapObject* obj = iterator.next(); obj != NULL; obj =
iterator.next()) {
for (int i = 0; i < size; i++) {
if (*objs[i] == obj) {
found_count++;
@@ -1194,9 +1194,9 @@
intptr_t size_of_objects_1 = HEAP->SizeOfObjects();
HeapIterator iterator;
intptr_t size_of_objects_2 = 0;
- for (HeapObject* obj = iterator.Next();
+ for (HeapObject* obj = iterator.next();
obj != NULL;
- obj = iterator.Next()) {
+ obj = iterator.next()) {
size_of_objects_2 += obj->Size();
}
// Delta must be within 5% of the larger result.
@@ -1229,9 +1229,9 @@
bool b_found() { return b_found_; }
void IterateHeap() {
HeapIterator iterator;
- for (HeapObject* obj = iterator.Next();
+ for (HeapObject* obj = iterator.next();
obj != NULL;
- obj = iterator.Next()) {
+ obj = iterator.next()) {
if (obj == a_)
a_found_ = true;
else if (obj == b_)
--
v8-dev mailing list
[email protected]
http://groups.google.com/group/v8-dev
