obj->set_buffer(*buffer);
- obj->set_weak_next(buffer->weak_first_view());
- buffer->set_weak_first_view(*obj);
+ Heap* heap = isolate->heap();
+ if (heap->InNewSpace(*obj)) {
+ obj->set_weak_next(heap->new_array_buffer_views_list());
+ heap->set_new_array_buffer_views_list(*obj);
+ } else {
+ obj->set_weak_next(buffer->weak_first_view());
+ buffer->set_weak_first_view(*obj);
+ }
i::Handle<i::Object> byte_offset_object =
isolate->factory()->NewNumberFromSize(byte_offset);
chunks_queued_for_free_(NULL),
gc_callbacks_depth_(0),
deserialization_complete_(false),
- concurrent_sweeping_enabled_(false) {
+ concurrent_sweeping_enabled_(false),
+ migration_failure_(false),
+ previous_migration_failure_(false) {
// Allow build-time customization of the max semispace size. Building
// V8 with snapshots and a non-default max semispace size is much
// easier if you can define it as part of the build environment.
// Remember the last top pointer so that we can later find out
// whether we allocated in new space since the last GC.
new_space_top_after_last_gc_ = new_space()->top();
+
+ if (migration_failure_) {
+ set_previous_migration_failure(true);
+ } else {
+ set_previous_migration_failure(false);
+ }
+ set_migration_failure(false);
}
void Heap::ProcessAllWeakReferences(WeakObjectRetainer* retainer) {
- ProcessArrayBuffers(retainer);
+ ProcessArrayBuffers(retainer, false);
+ ProcessNewArrayBufferViews(retainer);
ProcessNativeContexts(retainer);
ProcessAllocationSites(retainer);
}
void Heap::ProcessYoungWeakReferences(WeakObjectRetainer* retainer) {
- ProcessArrayBuffers(retainer);
+ ProcessArrayBuffers(retainer, true);
+ ProcessNewArrayBufferViews(retainer);
ProcessNativeContexts(retainer);
}
void Heap::ProcessNativeContexts(WeakObjectRetainer* retainer) {
- Object* head = VisitWeakList<Context>(this, native_contexts_list(), retainer);
+ Object* head =
+ VisitWeakList<Context>(this, native_contexts_list(), retainer, false);
// Update the head of the list of contexts.
set_native_contexts_list(head);
}
-void Heap::ProcessArrayBuffers(WeakObjectRetainer* retainer) {
- Object* array_buffer_obj =
- VisitWeakList<JSArrayBuffer>(this, array_buffers_list(), retainer);
+void Heap::ProcessArrayBuffers(WeakObjectRetainer* retainer,
+ bool stop_after_young) {
+ Object* array_buffer_obj = VisitWeakList<JSArrayBuffer>(
+ this, array_buffers_list(), retainer, stop_after_young);
set_array_buffers_list(array_buffer_obj);
+
+#ifdef DEBUG
+ // Verify invariant that young array buffers come before old array buffers
+ // in array buffers list if there was no promotion failure.
+ Object* undefined = undefined_value();
+ Object* next = array_buffers_list();
+ bool old_objects_recorded = false;
+ if (migration_failure()) return;
+ while (next != undefined) {
+ if (!old_objects_recorded) {
+ old_objects_recorded = !InNewSpace(next);
+ }
+ DCHECK((InNewSpace(next) && !old_objects_recorded) || !InNewSpace(next));
+ next = JSArrayBuffer::cast(next)->weak_next();
+ }
+#endif
+}
+
+
+void Heap::ProcessNewArrayBufferViews(WeakObjectRetainer* retainer) {
+ // Retain the list of new space views.
+ Object* typed_array_obj = VisitWeakList<JSArrayBufferView>(
+ this, new_array_buffer_views_list_, retainer, false);
+ set_new_array_buffer_views_list(typed_array_obj);
+
+ // Some objects in the list may be in old space now. Find them
+ // and move them to the corresponding array buffer.
+ Object* view = VisitNewArrayBufferViewsWeakList(
+ this, new_array_buffer_views_list_, retainer);
+ set_new_array_buffer_views_list(view);
}
void Heap::ProcessAllocationSites(WeakObjectRetainer* retainer) {
- Object* allocation_site_obj =
- VisitWeakList<AllocationSite>(this, allocation_sites_list(), retainer);
+ Object* allocation_site_obj = VisitWeakList<AllocationSite>(
+ this, allocation_sites_list(), retainer, false);
set_allocation_sites_list(allocation_site_obj);
}
if (SemiSpaceCopyObject<alignment>(map, slot, object, object_size)) {
return;
}
+ heap->set_migration_failure(true);
}
if (PromoteObject<object_contents, alignment>(map, slot, object,
set_native_contexts_list(undefined_value());
set_array_buffers_list(undefined_value());
+ set_new_array_buffer_views_list(undefined_value());
set_allocation_sites_list(undefined_value());
return true;
}
void set_array_buffers_list(Object* object) { array_buffers_list_ = object; }
Object* array_buffers_list() const { return array_buffers_list_; }
+ void set_new_array_buffer_views_list(Object* object) {
+ new_array_buffer_views_list_ = object;
+ }
+ Object* new_array_buffer_views_list() const {
+ return new_array_buffer_views_list_;
+ }
+
void set_allocation_sites_list(Object* object) {
allocation_sites_list_ = object;
}
bool deserialization_complete() const { return deserialization_complete_; }
+ bool migration_failure() const { return migration_failure_; }
+ void set_migration_failure(bool migration_failure) {
+ migration_failure_ = migration_failure;
+ }
+
+ bool previous_migration_failure() const {
+ return previous_migration_failure_;
+ }
+ void set_previous_migration_failure(bool previous_migration_failure) {
+ previous_migration_failure_ = previous_migration_failure;
+ }
+
protected:
// Methods made available to tests.
bool inline_allocation_disabled_;
// Weak list heads, threaded through the objects.
- // List heads are initilized lazily and contain the undefined_value at start.
+ // List heads are initialized lazily and contain the undefined_value at start.
Object* native_contexts_list_;
Object* array_buffers_list_;
Object* allocation_sites_list_;
+ // This is a global list of array buffer views in new space. When the views
+ // get promoted, they are removed form the list and added to the corresponding
+ // array buffer.
+ Object* new_array_buffer_views_list_;
+
// List of encountered weak collections (JSWeakMap and JSWeakSet) during
// marking. It is initialized during marking, destroyed after marking and
// contains Smi(0) while marking is not active.
void MarkCompactEpilogue();
void ProcessNativeContexts(WeakObjectRetainer* retainer);
- void ProcessArrayBuffers(WeakObjectRetainer* retainer);
+ void ProcessArrayBuffers(WeakObjectRetainer* retainer, bool stop_after_young);
+ void ProcessNewArrayBufferViews(WeakObjectRetainer* retainer);
void ProcessAllocationSites(WeakObjectRetainer* retainer);
// Deopts all code that contains allocation instruction which are tenured or
bool concurrent_sweeping_enabled_;
+ // A migration failure indicates that a semi-space copy of an object during
+ // a scavenge failed and the object got promoted instead.
+ bool migration_failure_;
+
+ // A migration failure happened in the previous scavenge.
+ bool previous_migration_failure_;
+
friend class AlwaysAllocateScope;
friend class Deserializer;
friend class Factory;
template <class T>
-Object* VisitWeakList(Heap* heap, Object* list, WeakObjectRetainer* retainer) {
+Object* VisitWeakList(Heap* heap, Object* list, WeakObjectRetainer* retainer,
+ bool stop_after_young) {
Object* undefined = heap->undefined_value();
Object* head = undefined;
T* tail = NULL;
MarkCompactCollector* collector = heap->mark_compact_collector();
bool record_slots = MustRecordSlots(heap);
+
while (list != undefined) {
// Check whether to keep the candidate in the list.
T* candidate = reinterpret_cast<T*>(list);
+ T* original_candidate = candidate;
+
Object* retained = retainer->RetainAs(list);
if (retained != NULL) {
if (head == undefined) {
candidate = reinterpret_cast<T*>(retained);
tail = candidate;
-
// tail is a live object, visit it.
WeakListVisitor<T>::VisitLiveObject(heap, tail, retainer);
+
+ // The list of weak objects is usually order. It starts with objects
+ // recently allocated in the young generation followed by objects
+ // allocated in the old generation. When a migration failure happened,
+ // the list is not ordered until the next GC that has no migration
+ // failure.
+ // For young generation collections we just have to visit until the last
+ // young generation objects.
+ if (stop_after_young && !heap->migration_failure() &&
+ !heap->previous_migration_failure() &&
+ !heap->InNewSpace(original_candidate)) {
+ return head;
+ }
} else {
WeakListVisitor<T>::VisitPhantomObject(heap, candidate);
}
}
+Object* VisitNewArrayBufferViewsWeakList(Heap* heap, Object* list,
+ WeakObjectRetainer* retainer) {
+ Object* undefined = heap->undefined_value();
+ Object* previous = undefined;
+ Object* head = undefined;
+ Object* next;
+ MarkCompactCollector* collector = heap->mark_compact_collector();
+ bool record_slots = MustRecordSlots(heap);
+
+ for (Object* o = list; o != undefined;) {
+ JSArrayBufferView* view = JSArrayBufferView::cast(o);
+ next = view->weak_next();
+ if (!heap->InNewSpace(view)) {
+ if (previous != undefined) {
+ // We are in the middle of the list, skip the old space element.
+ JSArrayBufferView* previous_view = JSArrayBufferView::cast(previous);
+ previous_view->set_weak_next(next);
+ if (record_slots) {
+ Object** next_slot = HeapObject::RawField(
+ previous_view, JSArrayBufferView::kWeakNextOffset);
+ collector->RecordSlot(next_slot, next_slot, next);
+ }
+ }
+ JSArrayBuffer* buffer = JSArrayBuffer::cast(view->buffer());
+ view->set_weak_next(buffer->weak_first_view());
+ if (record_slots) {
+ Object** next_slot =
+ HeapObject::RawField(view, JSArrayBufferView::kWeakNextOffset);
+ collector->RecordSlot(next_slot, next_slot, buffer->weak_first_view());
+ }
+ buffer->set_weak_first_view(view);
+ if (record_slots) {
+ Object** slot =
+ HeapObject::RawField(buffer, JSArrayBuffer::kWeakFirstViewOffset);
+ heap->mark_compact_collector()->RecordSlot(slot, slot, view);
+ }
+ } else {
+ // We found a valid new space view, remember it.
+ previous = view;
+ if (head == undefined) {
+ // We are at the list head.
+ head = view;
+ }
+ }
+ o = next;
+ }
+ return head;
+}
+
+
template <class T>
static void ClearWeakList(Heap* heap, Object* list) {
Object* undefined = heap->undefined_value();
static void DoWeakList(Heap* heap, Context* context,
WeakObjectRetainer* retainer, int index) {
// Visit the weak list, removing dead intermediate elements.
- Object* list_head = VisitWeakList<T>(heap, context->get(index), retainer);
+ Object* list_head =
+ VisitWeakList<T>(heap, context->get(index), retainer, false);
// Update the list head.
context->set(index, list_head, UPDATE_WRITE_BARRIER);
static void VisitLiveObject(Heap* heap, JSArrayBuffer* array_buffer,
WeakObjectRetainer* retainer) {
Object* typed_array_obj = VisitWeakList<JSArrayBufferView>(
- heap, array_buffer->weak_first_view(), retainer);
+ heap, array_buffer->weak_first_view(), retainer, false);
array_buffer->set_weak_first_view(typed_array_obj);
if (typed_array_obj != heap->undefined_value() && MustRecordSlots(heap)) {
Object** slot = HeapObject::RawField(array_buffer,
};
-template Object* VisitWeakList<Code>(Heap* heap, Object* list,
- WeakObjectRetainer* retainer);
-
-
-template Object* VisitWeakList<JSFunction>(Heap* heap, Object* list,
- WeakObjectRetainer* retainer);
-
-
template Object* VisitWeakList<Context>(Heap* heap, Object* list,
- WeakObjectRetainer* retainer);
+ WeakObjectRetainer* retainer,
+ bool stop_after_young);
template Object* VisitWeakList<JSArrayBuffer>(Heap* heap, Object* list,
- WeakObjectRetainer* retainer);
+ WeakObjectRetainer* retainer,
+ bool stop_after_young);
+template Object* VisitWeakList<JSArrayBufferView>(Heap* heap, Object* list,
+ WeakObjectRetainer* retainer,
+ bool stop_after_young);
template Object* VisitWeakList<AllocationSite>(Heap* heap, Object* list,
- WeakObjectRetainer* retainer);
+ WeakObjectRetainer* retainer,
+ bool stop_after_young);
}
} // namespace v8::internal
// pointers. The template parameter T is a WeakListVisitor that defines how to
// access the next-element pointers.
template <class T>
-Object* VisitWeakList(Heap* heap, Object* list, WeakObjectRetainer* retainer);
+Object* VisitWeakList(Heap* heap, Object* list, WeakObjectRetainer* retainer,
+ bool stop_after_young);
+Object* VisitNewArrayBufferViewsWeakList(Heap* heap, Object* list,
+ WeakObjectRetainer* retainer);
}
} // namespace v8::internal
fixed_typed_array->length(), typed_array->type(),
static_cast<uint8_t*>(buffer->backing_store()));
- buffer->set_weak_first_view(*typed_array);
- DCHECK(typed_array->weak_next() == isolate->heap()->undefined_value());
+ Heap* heap = isolate->heap();
+ if (heap->InNewSpace(*typed_array)) {
+ DCHECK(typed_array->weak_next() == isolate->heap()->undefined_value());
+ typed_array->set_weak_next(heap->new_array_buffer_views_list());
+ heap->set_new_array_buffer_views_list(*typed_array);
+ } else {
+ buffer->set_weak_first_view(*typed_array);
+ DCHECK(typed_array->weak_next() == isolate->heap()->undefined_value());
+ }
typed_array->set_buffer(*buffer);
JSObject::SetMapAndElements(typed_array, new_map, new_elements);
void Runtime::NeuterArrayBuffer(Handle<JSArrayBuffer> array_buffer) {
Isolate* isolate = array_buffer->GetIsolate();
+ // Firstly, iterate over the views which are referenced directly by the array
+ // buffer.
for (Handle<Object> view_obj(array_buffer->weak_first_view(), isolate);
!view_obj->IsUndefined();) {
Handle<JSArrayBufferView> view(JSArrayBufferView::cast(*view_obj));
}
view_obj = handle(view->weak_next(), isolate);
}
+
+ // Secondly, iterate over the global list of new space views to find views
+ // that belong to the neutered array buffer.
+ Heap* heap = isolate->heap();
+ for (Handle<Object> view_obj(heap->new_array_buffer_views_list(), isolate);
+ !view_obj->IsUndefined();) {
+ Handle<JSArrayBufferView> view(JSArrayBufferView::cast(*view_obj));
+ if (view->buffer() == *array_buffer) {
+ if (view->IsJSTypedArray()) {
+ JSTypedArray::cast(*view)->Neuter();
+ } else if (view->IsJSDataView()) {
+ JSDataView::cast(*view)->Neuter();
+ } else {
+ UNREACHABLE();
+ }
+ }
+ view_obj = handle(view->weak_next(), isolate);
+ }
array_buffer->Neuter();
}
holder->set_byte_offset(*byte_offset_object);
holder->set_byte_length(*byte_length_object);
+ Heap* heap = isolate->heap();
if (!maybe_buffer->IsNull()) {
Handle<JSArrayBuffer> buffer = Handle<JSArrayBuffer>::cast(maybe_buffer);
holder->set_buffer(*buffer);
- holder->set_weak_next(buffer->weak_first_view());
- buffer->set_weak_first_view(*holder);
+
+ if (heap->InNewSpace(*holder)) {
+ holder->set_weak_next(heap->new_array_buffer_views_list());
+ heap->set_new_array_buffer_views_list(*holder);
+ } else {
+ holder->set_weak_next(buffer->weak_first_view());
+ buffer->set_weak_first_view(*holder);
+ }
Handle<ExternalArray> elements = isolate->factory()->NewExternalArray(
static_cast<int>(length), array_type,
isolate->factory()->NewNumberFromSize(byte_length));
holder->set_byte_length(*byte_length_obj);
holder->set_length(*length_obj);
- holder->set_weak_next(buffer->weak_first_view());
- buffer->set_weak_first_view(*holder);
+
+ Heap* heap = isolate->heap();
+ if (heap->InNewSpace(*holder)) {
+ holder->set_weak_next(heap->new_array_buffer_views_list());
+ heap->set_new_array_buffer_views_list(*holder);
+ } else {
+ holder->set_weak_next(buffer->weak_first_view());
+ buffer->set_weak_first_view(*holder);
+ }
Handle<ExternalArray> elements = isolate->factory()->NewExternalArray(
static_cast<int>(length), array_type,
holder->set_byte_offset(*byte_offset);
holder->set_byte_length(*byte_length);
- holder->set_weak_next(buffer->weak_first_view());
- buffer->set_weak_first_view(*holder);
+ Heap* heap = isolate->heap();
+ if (heap->InNewSpace(*holder)) {
+ holder->set_weak_next(heap->new_array_buffer_views_list());
+ heap->set_new_array_buffer_views_list(*holder);
+ } else {
+ holder->set_weak_next(buffer->weak_first_view());
+ buffer->set_weak_first_view(*holder);
+ }
return isolate->heap()->undefined_value();
}
isolate_->heap()->undefined_value());
isolate_->heap()->set_array_buffers_list(
isolate_->heap()->undefined_value());
+ isolate->heap()->set_new_array_buffer_views_list(
+ isolate_->heap()->undefined_value());
// The allocation site list is build during root iteration, but if no sites
// were encountered then it needs to be initialized to undefined.
}
-static int CountViews(JSArrayBuffer* array_buffer) {
+static int CountViewsInNewSpaceList(Heap* heap, JSArrayBuffer* array_buffer) {
+ int count = 0;
+ for (Object* o = heap->new_array_buffer_views_list(); !o->IsUndefined();) {
+ JSArrayBufferView* view = JSArrayBufferView::cast(o);
+ if (array_buffer == view->buffer()) {
+ count++;
+ }
+ o = view->weak_next();
+ }
+ return count;
+}
+
+
+static int CountViews(Heap* heap, JSArrayBuffer* array_buffer) {
int count = 0;
for (Object* o = array_buffer->weak_first_view();
!o->IsUndefined();
count++;
}
- return count;
+ return count + CountViewsInNewSpaceList(heap, array_buffer);
}
-static bool HasViewInWeakList(JSArrayBuffer* array_buffer,
+
+static bool HasViewInNewSpaceList(Heap* heap, JSArrayBufferView* ta) {
+ for (Object* o = heap->new_array_buffer_views_list(); !o->IsUndefined();
+ o = JSArrayBufferView::cast(o)->weak_next()) {
+ if (ta == o) return true;
+ }
+ return false;
+}
+
+
+static bool HasViewInWeakList(Heap* heap, JSArrayBuffer* array_buffer,
JSArrayBufferView* ta) {
for (Object* o = array_buffer->weak_first_view();
!o->IsUndefined();
o = JSArrayBufferView::cast(o)->weak_next()) {
if (ta == o) return true;
}
- return false;
+ return HasViewInNewSpaceList(heap, ta);
}
Handle<JSArrayBufferView> ita1 = v8::Utils::OpenHandle(*ta1);
Handle<JSArrayBufferView> ita2 = v8::Utils::OpenHandle(*ta2);
- CHECK_EQ(2, CountViews(*iab));
- CHECK(HasViewInWeakList(*iab, *ita1));
- CHECK(HasViewInWeakList(*iab, *ita2));
+ CHECK_EQ(2, CountViews(isolate->heap(), *iab));
+ CHECK(HasViewInWeakList(isolate->heap(), *iab, *ita1));
+ CHECK(HasViewInWeakList(isolate->heap(), *iab, *ita2));
}
isolate->heap()->CollectAllGarbage(Heap::kAbortIncrementalMarkingMask);
- CHECK_EQ(1, CountViews(*iab));
+ CHECK_EQ(1, CountViews(isolate->heap(), *iab));
Handle<JSArrayBufferView> ita1 = v8::Utils::OpenHandle(*ta1);
- CHECK(HasViewInWeakList(*iab, *ita1));
+ CHECK(HasViewInWeakList(isolate->heap(), *iab, *ita1));
}
isolate->heap()->CollectAllGarbage(Heap::kAbortIncrementalMarkingMask);
- CHECK_EQ(0, CountViews(*iab));
+ CHECK_EQ(0, CountViews(isolate->heap(), *iab));
}
v8::Handle<TypedArray>::Cast(CompileRun("ta3"));
CHECK_EQ(1, CountArrayBuffersInWeakList(isolate->heap()) - start);
Handle<JSArrayBuffer> iab = v8::Utils::OpenHandle(*ab);
- CHECK_EQ(3, CountViews(*iab));
- CHECK(HasViewInWeakList(*iab, *v8::Utils::OpenHandle(*ta1)));
- CHECK(HasViewInWeakList(*iab, *v8::Utils::OpenHandle(*ta2)));
- CHECK(HasViewInWeakList(*iab, *v8::Utils::OpenHandle(*ta3)));
+ CHECK_EQ(3, CountViews(isolate->heap(), *iab));
+ CHECK(HasViewInWeakList(isolate->heap(), *iab,
+ *v8::Utils::OpenHandle(*ta1)));
+ CHECK(HasViewInWeakList(isolate->heap(), *iab,
+ *v8::Utils::OpenHandle(*ta2)));
+ CHECK(HasViewInWeakList(isolate->heap(), *iab,
+ *v8::Utils::OpenHandle(*ta3)));
}
i::SNPrintF(source, "ta%d = null;", i);
v8::Handle<v8::ArrayBuffer> ab =
v8::Handle<v8::ArrayBuffer>::Cast(CompileRun("ab"));
Handle<JSArrayBuffer> iab = v8::Utils::OpenHandle(*ab);
- CHECK_EQ(2, CountViews(*iab));
+ CHECK_EQ(2, CountViews(isolate->heap(), *iab));
for (int j = 1; j <= 3; j++) {
if (j == i) continue;
i::SNPrintF(source, "ta%d", j);
v8::Handle<TypedArray> ta =
v8::Handle<TypedArray>::Cast(CompileRun(source.start()));
- CHECK(HasViewInWeakList(*iab, *v8::Utils::OpenHandle(*ta)));
+ CHECK(HasViewInWeakList(isolate->heap(), *iab,
+ *v8::Utils::OpenHandle(*ta)));
}
}
v8::Handle<v8::ArrayBuffer> ab =
v8::Handle<v8::ArrayBuffer>::Cast(CompileRun("ab"));
Handle<JSArrayBuffer> iab = v8::Utils::OpenHandle(*ab);
- CHECK_EQ(0, CountViews(*iab));
+ CHECK_EQ(0, CountViews(isolate->heap(), *iab));
}
}
}
projects / platform / upstream / v8.git / commitdiff