From c5c32e18add0787327f8f26e94aff2f5531f922c Mon Sep 17 00:00:00 2001 From: "erik.corry@gmail.com" Date: Wed, 7 Dec 2011 08:43:18 +0000 Subject: [PATCH] More removal of write barriers and a rename to a less scary name. Review URL: http://codereview.chromium.org/8816020 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@10186 ce2b1a6d-e550-0410-aec6-3dcde31c8c00 --- src/heap-inl.h | 2 +- src/heap.cc | 78 ++++++++++++++++++++++++++++++------------------------- src/objects-inl.h | 4 +-- src/objects.cc | 24 +++++++++-------- src/objects.h | 5 +++- src/runtime.cc | 5 ++-- src/spaces.cc | 6 ++--- 7 files changed, 67 insertions(+), 57 deletions(-) diff --git a/src/heap-inl.h b/src/heap-inl.h index 529e994..ef6e58e 100644 --- a/src/heap-inl.h +++ b/src/heap-inl.h @@ -126,7 +126,7 @@ MaybeObject* Heap::AllocateAsciiSymbol(Vector str, } // String maps are all immortal immovable objects. - reinterpret_cast(result)->set_map_unsafe(map); + reinterpret_cast(result)->set_map_no_write_barrier(map); // Set length and hash fields of the allocated string. String* answer = String::cast(result); answer->set_length(str.length()); diff --git a/src/heap.cc b/src/heap.cc index bf9c82f..8d3ed53 100644 --- a/src/heap.cc +++ b/src/heap.cc @@ -1813,7 +1813,7 @@ MaybeObject* Heap::AllocateMap(InstanceType instance_type, } Map* map = reinterpret_cast(result); - map->set_map_unsafe(meta_map()); + map->set_map_no_write_barrier(meta_map()); map->set_instance_type(instance_type); map->set_visitor_id( StaticVisitorBase::GetVisitorId(instance_type, instance_size)); @@ -2173,7 +2173,7 @@ MaybeObject* Heap::AllocateHeapNumber(double value, PretenureFlag pretenure) { if (!maybe_result->ToObject(&result)) return maybe_result; } - HeapObject::cast(result)->set_map_unsafe(heap_number_map()); + HeapObject::cast(result)->set_map_no_write_barrier(heap_number_map()); HeapNumber::cast(result)->set_value(value); return result; } @@ -2191,7 +2191,7 @@ MaybeObject* Heap::AllocateHeapNumber(double value) { { MaybeObject* maybe_result = new_space_.AllocateRaw(HeapNumber::kSize); if (!maybe_result->ToObject(&result)) return maybe_result; } - HeapObject::cast(result)->set_map_unsafe(heap_number_map()); + HeapObject::cast(result)->set_map_no_write_barrier(heap_number_map()); HeapNumber::cast(result)->set_value(value); return result; } @@ -2202,7 +2202,8 @@ MaybeObject* Heap::AllocateJSGlobalPropertyCell(Object* value) { { MaybeObject* maybe_result = AllocateRawCell(); if (!maybe_result->ToObject(&result)) return maybe_result; } - HeapObject::cast(result)->set_map_unsafe(global_property_cell_map()); + HeapObject::cast(result)->set_map_no_write_barrier( + global_property_cell_map()); JSGlobalPropertyCell::cast(result)->set_value(value); return result; } @@ -2543,7 +2544,7 @@ void StringSplitCache::Enter(Heap* heap, } } } - array->set_map(heap->fixed_cow_array_map()); + array->set_map_no_write_barrier(heap->fixed_cow_array_map()); } @@ -3139,7 +3140,8 @@ MaybeObject* Heap::AllocateByteArray(int length, PretenureFlag pretenure) { if (!maybe_result->ToObject(&result)) return maybe_result; } - reinterpret_cast(result)->set_map_unsafe(byte_array_map()); + reinterpret_cast(result)->set_map_no_write_barrier( + byte_array_map()); reinterpret_cast(result)->set_length(length); return result; } @@ -3157,7 +3159,8 @@ MaybeObject* Heap::AllocateByteArray(int length) { if (!maybe_result->ToObject(&result)) return maybe_result; } - reinterpret_cast(result)->set_map_unsafe(byte_array_map()); + reinterpret_cast(result)->set_map_no_write_barrier( + byte_array_map()); reinterpret_cast(result)->set_length(length); return result; } @@ -3167,11 +3170,11 @@ void Heap::CreateFillerObjectAt(Address addr, int size) { if (size == 0) return; HeapObject* filler = HeapObject::FromAddress(addr); if (size == kPointerSize) { - filler->set_map_unsafe(one_pointer_filler_map()); + filler->set_map_no_write_barrier(one_pointer_filler_map()); } else if (size == 2 * kPointerSize) { - filler->set_map_unsafe(two_pointer_filler_map()); + filler->set_map_no_write_barrier(two_pointer_filler_map()); } else { - filler->set_map_unsafe(free_space_map()); + filler->set_map_no_write_barrier(free_space_map()); FreeSpace::cast(filler)->set_size(size); } } @@ -3189,7 +3192,7 @@ MaybeObject* Heap::AllocateExternalArray(int length, if (!maybe_result->ToObject(&result)) return maybe_result; } - reinterpret_cast(result)->set_map_unsafe( + reinterpret_cast(result)->set_map_no_write_barrier( MapForExternalArrayType(array_type)); reinterpret_cast(result)->set_length(length); reinterpret_cast(result)->set_external_pointer( @@ -3226,7 +3229,7 @@ MaybeObject* Heap::CreateCode(const CodeDesc& desc, if (!maybe_result->ToObject(&result)) return maybe_result; // Initialize the object - HeapObject::cast(result)->set_map_unsafe(code_map()); + HeapObject::cast(result)->set_map_no_write_barrier(code_map()); Code* code = Code::cast(result); ASSERT(!isolate_->code_range()->exists() || isolate_->code_range()->contains(code->address())); @@ -3355,7 +3358,7 @@ MaybeObject* Heap::Allocate(Map* map, AllocationSpace space) { if (!maybe_result->ToObject(&result)) return maybe_result; } // No need for write barrier since object is white and map is in old space. - HeapObject::cast(result)->set_map_unsafe(map); + HeapObject::cast(result)->set_map_no_write_barrier(map); return result; } @@ -4084,7 +4087,7 @@ MaybeObject* Heap::AllocateInternalSymbol(unibrow::CharacterStream* buffer, if (!maybe_result->ToObject(&result)) return maybe_result; } - reinterpret_cast(result)->set_map_unsafe(map); + reinterpret_cast(result)->set_map_no_write_barrier(map); // Set length and hash fields of the allocated string. String* answer = String::cast(result); answer->set_length(chars); @@ -4128,7 +4131,7 @@ MaybeObject* Heap::AllocateRawAsciiString(int length, PretenureFlag pretenure) { } // Partially initialize the object. - HeapObject::cast(result)->set_map_unsafe(ascii_string_map()); + HeapObject::cast(result)->set_map_no_write_barrier(ascii_string_map()); String::cast(result)->set_length(length); String::cast(result)->set_hash_field(String::kEmptyHashField); ASSERT_EQ(size, HeapObject::cast(result)->Size()); @@ -4163,7 +4166,7 @@ MaybeObject* Heap::AllocateRawTwoByteString(int length, } // Partially initialize the object. - HeapObject::cast(result)->set_map_unsafe(string_map()); + HeapObject::cast(result)->set_map_no_write_barrier(string_map()); String::cast(result)->set_length(length); String::cast(result)->set_hash_field(String::kEmptyHashField); ASSERT_EQ(size, HeapObject::cast(result)->Size()); @@ -4179,7 +4182,8 @@ MaybeObject* Heap::AllocateEmptyFixedArray() { if (!maybe_result->ToObject(&result)) return maybe_result; } // Initialize the object. - reinterpret_cast(result)->set_map_unsafe(fixed_array_map()); + reinterpret_cast(result)->set_map_no_write_barrier( + fixed_array_map()); reinterpret_cast(result)->set_length(0); return result; } @@ -4208,13 +4212,13 @@ MaybeObject* Heap::CopyFixedArrayWithMap(FixedArray* src, Map* map) { } if (InNewSpace(obj)) { HeapObject* dst = HeapObject::cast(obj); - dst->set_map_unsafe(map); + dst->set_map_no_write_barrier(map); CopyBlock(dst->address() + kPointerSize, src->address() + kPointerSize, FixedArray::SizeFor(len) - kPointerSize); return obj; } - HeapObject::cast(obj)->set_map_unsafe(map); + HeapObject::cast(obj)->set_map_no_write_barrier(map); FixedArray* result = FixedArray::cast(obj); result->set_length(len); @@ -4234,7 +4238,7 @@ MaybeObject* Heap::CopyFixedDoubleArrayWithMap(FixedDoubleArray* src, if (!maybe_obj->ToObject(&obj)) return maybe_obj; } HeapObject* dst = HeapObject::cast(obj); - dst->set_map_unsafe(map); + dst->set_map_no_write_barrier(map); CopyBlock( dst->address() + FixedDoubleArray::kLengthOffset, src->address() + FixedDoubleArray::kLengthOffset, @@ -4252,7 +4256,7 @@ MaybeObject* Heap::AllocateFixedArray(int length) { } // Initialize header. FixedArray* array = reinterpret_cast(result); - array->set_map_unsafe(fixed_array_map()); + array->set_map_no_write_barrier(fixed_array_map()); array->set_length(length); // Initialize body. ASSERT(!InNewSpace(undefined_value())); @@ -4300,7 +4304,7 @@ MUST_USE_RESULT static MaybeObject* AllocateFixedArrayWithFiller( if (!maybe_result->ToObject(&result)) return maybe_result; } - HeapObject::cast(result)->set_map_unsafe(heap->fixed_array_map()); + HeapObject::cast(result)->set_map_no_write_barrier(heap->fixed_array_map()); FixedArray* array = FixedArray::cast(result); array->set_length(length); MemsetPointer(array->data_start(), filler, length); @@ -4333,7 +4337,8 @@ MaybeObject* Heap::AllocateUninitializedFixedArray(int length) { if (!maybe_obj->ToObject(&obj)) return maybe_obj; } - reinterpret_cast(obj)->set_map_unsafe(fixed_array_map()); + reinterpret_cast(obj)->set_map_no_write_barrier( + fixed_array_map()); FixedArray::cast(obj)->set_length(length); return obj; } @@ -4347,7 +4352,7 @@ MaybeObject* Heap::AllocateEmptyFixedDoubleArray() { if (!maybe_result->ToObject(&result)) return maybe_result; } // Initialize the object. - reinterpret_cast(result)->set_map_unsafe( + reinterpret_cast(result)->set_map_no_write_barrier( fixed_double_array_map()); reinterpret_cast(result)->set_length(0); return result; @@ -4364,7 +4369,7 @@ MaybeObject* Heap::AllocateUninitializedFixedDoubleArray( if (!maybe_obj->ToObject(&obj)) return maybe_obj; } - reinterpret_cast(obj)->set_map_unsafe( + reinterpret_cast(obj)->set_map_no_write_barrier( fixed_double_array_map()); FixedDoubleArray::cast(obj)->set_length(length); return obj; @@ -4401,7 +4406,8 @@ MaybeObject* Heap::AllocateHashTable(int length, PretenureFlag pretenure) { { MaybeObject* maybe_result = AllocateFixedArray(length, pretenure); if (!maybe_result->ToObject(&result)) return maybe_result; } - reinterpret_cast(result)->set_map_unsafe(hash_table_map()); + reinterpret_cast(result)->set_map_no_write_barrier( + hash_table_map()); ASSERT(result->IsHashTable()); return result; } @@ -4414,7 +4420,7 @@ MaybeObject* Heap::AllocateGlobalContext() { if (!maybe_result->ToObject(&result)) return maybe_result; } Context* context = reinterpret_cast(result); - context->set_map_unsafe(global_context_map()); + context->set_map_no_write_barrier(global_context_map()); ASSERT(context->IsGlobalContext()); ASSERT(result->IsContext()); return result; @@ -4428,7 +4434,7 @@ MaybeObject* Heap::AllocateFunctionContext(int length, JSFunction* function) { if (!maybe_result->ToObject(&result)) return maybe_result; } Context* context = reinterpret_cast(result); - context->set_map_unsafe(function_context_map()); + context->set_map_no_write_barrier(function_context_map()); context->set_closure(function); context->set_previous(function->context()); context->set_extension(NULL); @@ -4448,7 +4454,7 @@ MaybeObject* Heap::AllocateCatchContext(JSFunction* function, if (!maybe_result->ToObject(&result)) return maybe_result; } Context* context = reinterpret_cast(result); - context->set_map_unsafe(catch_context_map()); + context->set_map_no_write_barrier(catch_context_map()); context->set_closure(function); context->set_previous(previous); context->set_extension(name); @@ -4466,7 +4472,7 @@ MaybeObject* Heap::AllocateWithContext(JSFunction* function, if (!maybe_result->ToObject(&result)) return maybe_result; } Context* context = reinterpret_cast(result); - context->set_map_unsafe(with_context_map()); + context->set_map_no_write_barrier(with_context_map()); context->set_closure(function); context->set_previous(previous); context->set_extension(extension); @@ -4484,7 +4490,7 @@ MaybeObject* Heap::AllocateBlockContext(JSFunction* function, if (!maybe_result->ToObject(&result)) return maybe_result; } Context* context = reinterpret_cast(result); - context->set_map_unsafe(block_context_map()); + context->set_map_no_write_barrier(block_context_map()); context->set_closure(function); context->set_previous(previous); context->set_extension(scope_info); @@ -4497,7 +4503,7 @@ MaybeObject* Heap::AllocateScopeInfo(int length) { FixedArray* scope_info; MaybeObject* maybe_scope_info = AllocateFixedArray(length, TENURED); if (!maybe_scope_info->To(&scope_info)) return maybe_scope_info; - scope_info->set_map_unsafe(scope_info_map()); + scope_info->set_map_no_write_barrier(scope_info_map()); return scope_info; } @@ -5415,7 +5421,7 @@ class HeapDebugUtils { Address map_addr = map_p->address(); - obj->set_map(reinterpret_cast(map_addr + kMarkTag)); + obj->set_map_no_write_barrier(reinterpret_cast(map_addr + kMarkTag)); MarkObjectRecursively(&map); @@ -5462,7 +5468,7 @@ class HeapDebugUtils { HeapObject* map_p = HeapObject::FromAddress(map_addr); - obj->set_map(reinterpret_cast(map_p)); + obj->set_map_no_write_barrier(reinterpret_cast(map_p)); UnmarkObjectRecursively(reinterpret_cast(&map_p)); @@ -6174,7 +6180,7 @@ void PathTracer::MarkRecursively(Object** p, MarkVisitor* mark_visitor) { Address map_addr = map_p->address(); - obj->set_map(reinterpret_cast(map_addr + kMarkTag)); + obj->set_map_no_write_barrier(reinterpret_cast(map_addr + kMarkTag)); // Scan the object body. if (is_global_context && (visit_mode_ == VISIT_ONLY_STRONG)) { @@ -6216,7 +6222,7 @@ void PathTracer::UnmarkRecursively(Object** p, UnmarkVisitor* unmark_visitor) { HeapObject* map_p = HeapObject::FromAddress(map_addr); - obj->set_map(reinterpret_cast(map_p)); + obj->set_map_no_write_barrier(reinterpret_cast(map_p)); UnmarkRecursively(reinterpret_cast(&map_p), unmark_visitor); diff --git a/src/objects-inl.h b/src/objects-inl.h index 963008a..1eaae3c 100644 --- a/src/objects-inl.h +++ b/src/objects-inl.h @@ -1115,7 +1115,7 @@ void HeapObject::set_map(Map* value) { // Unsafe accessor omitting write barrier. -void HeapObject::set_map_unsafe(Map* value) { +void HeapObject::set_map_no_write_barrier(Map* value) { set_map_word(MapWord::FromMap(value)); } @@ -1311,8 +1311,6 @@ void JSGlobalPropertyCell::set_value(Object* val, WriteBarrierMode ignored) { // The write barrier is not used for global property cells. ASSERT(!val->IsJSGlobalPropertyCell()); WRITE_FIELD(this, kValueOffset, val); - GetHeap()->incremental_marking()->RecordWrite( - this, HeapObject::RawField(this, kValueOffset), val); } diff --git a/src/objects.cc b/src/objects.cc index edc718a..5c8a898 100644 --- a/src/objects.cc +++ b/src/objects.cc @@ -961,14 +961,14 @@ bool String::MakeExternal(v8::String::ExternalStringResource* resource) { // Morph the object to an external string by adjusting the map and // reinitializing the fields. if (size >= ExternalString::kSize) { - this->set_map( + this->set_map_no_write_barrier( is_symbol ? (is_ascii ? heap->external_symbol_with_ascii_data_map() : heap->external_symbol_map()) : (is_ascii ? heap->external_string_with_ascii_data_map() : heap->external_string_map())); } else { - this->set_map( + this->set_map_no_write_barrier( is_symbol ? (is_ascii ? heap->short_external_symbol_with_ascii_data_map() : heap->short_external_symbol_map()) @@ -1011,11 +1011,13 @@ bool String::MakeExternal(v8::String::ExternalAsciiStringResource* resource) { // Morph the object to an external string by adjusting the map and // reinitializing the fields. Use short version if space is limited. if (size >= ExternalString::kSize) { - this->set_map(is_symbol ? heap->external_ascii_symbol_map() - : heap->external_ascii_string_map()); + this->set_map_no_write_barrier( + is_symbol ? heap->external_ascii_symbol_map() + : heap->external_ascii_string_map()); } else { - this->set_map(is_symbol ? heap->short_external_ascii_symbol_map() - : heap->short_external_ascii_string_map()); + this->set_map_no_write_barrier( + is_symbol ? heap->short_external_ascii_symbol_map() + : heap->short_external_ascii_string_map()); } ExternalAsciiString* self = ExternalAsciiString::cast(this); self->set_resource(resource); @@ -4852,7 +4854,7 @@ void Map::TraverseTransitionTree(TraverseCallback callback, void* data) { // of the next map and recording the index in the transition array in // the map field of the array. Map* next = Map::cast(contents->get(i)); - next->set_map_unsafe(current); + next->set_map_no_write_barrier(current); *map_or_index_field = Smi::FromInt(i + 2); current = next; map_done = false; @@ -4877,7 +4879,7 @@ void Map::TraverseTransitionTree(TraverseCallback callback, void* data) { Object* perhaps_map = prototype_transitions->get(i); if (perhaps_map->IsMap()) { Map* next = Map::cast(perhaps_map); - next->set_map_unsafe(current); + next->set_map_no_write_barrier(current); *proto_map_or_index_field = Smi::FromInt(i + kProtoTransitionElementsPerEntry); current = next; @@ -4893,7 +4895,7 @@ void Map::TraverseTransitionTree(TraverseCallback callback, void* data) { // the map field, which is being used to track the traversal and put the // correct map (the meta_map) in place while we do the callback. Map* prev = current->map(); - current->set_map_unsafe(meta_map); + current->set_map_no_write_barrier(meta_map); callback(current, data); current = prev; } @@ -5394,7 +5396,7 @@ MaybeObject* FixedArray::CopySize(int new_length) { if (new_length < len) len = new_length; // We are taking the map from the old fixed array so the map is sure to // be an immortal immutable object. - result->set_map_unsafe(map()); + result->set_map_no_write_barrier(map()); WriteBarrierMode mode = result->GetWriteBarrierMode(no_gc); for (int i = 0; i < len; i++) { result->set(i, get(i), mode); @@ -10624,7 +10626,7 @@ class SymbolKey : public HashTableKey { // Transform string to symbol if possible. Map* map = heap->SymbolMapForString(string_); if (map != NULL) { - string_->set_map(map); + string_->set_map_no_write_barrier(map); ASSERT(string_->IsSymbol()); return string_; } diff --git a/src/objects.h b/src/objects.h index 1d8f79c..f5fdff7 100644 --- a/src/objects.h +++ b/src/objects.h @@ -1131,7 +1131,10 @@ class HeapObject: public Object { // information. inline Map* map(); inline void set_map(Map* value); - inline void set_map_unsafe(Map* value); + // The no-write-barrier version. This is OK if the object is white and in + // new space, or if the value is an immortal immutable object, like the maps + // of primitive (non-JS) objects like strings, heap numbers etc. + inline void set_map_no_write_barrier(Map* value); // During garbage collection, the map word of a heap object does not // necessarily contain a map pointer. diff --git a/src/runtime.cc b/src/runtime.cc index 3b9d148..0813e7d 100644 --- a/src/runtime.cc +++ b/src/runtime.cc @@ -7997,7 +7997,7 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_NewStrictArgumentsFast) { AssertNoAllocation no_gc; FixedArray* array = reinterpret_cast(obj); - array->set_map(isolate->heap()->fixed_array_map()); + array->set_map_no_write_barrier(isolate->heap()->fixed_array_map()); array->set_length(length); WriteBarrierMode mode = array->GetWriteBarrierMode(no_gc); @@ -8117,7 +8117,8 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_FunctionBindArguments) { for (int j = 0; j < argc; j++, i++) { new_bindings->set(i, *arguments[j + 1]); } - new_bindings->set_map(isolate->heap()->fixed_cow_array_map()); + new_bindings->set_map_no_write_barrier( + isolate->heap()->fixed_cow_array_map()); bound_function->set_function_bindings(*new_bindings); // Update length. diff --git a/src/spaces.cc b/src/spaces.cc index 1be81dd..a5712a0 100644 --- a/src/spaces.cc +++ b/src/spaces.cc @@ -1656,14 +1656,14 @@ void FreeListNode::set_size(Heap* heap, int size_in_bytes) { // field and a next pointer, we give it a filler map that gives it the // correct size. if (size_in_bytes > FreeSpace::kHeaderSize) { - set_map_unsafe(heap->raw_unchecked_free_space_map()); + set_map_no_write_barrier(heap->raw_unchecked_free_space_map()); // Can't use FreeSpace::cast because it fails during deserialization. FreeSpace* this_as_free_space = reinterpret_cast(this); this_as_free_space->set_size(size_in_bytes); } else if (size_in_bytes == kPointerSize) { - set_map_unsafe(heap->raw_unchecked_one_pointer_filler_map()); + set_map_no_write_barrier(heap->raw_unchecked_one_pointer_filler_map()); } else if (size_in_bytes == 2 * kPointerSize) { - set_map_unsafe(heap->raw_unchecked_two_pointer_filler_map()); + set_map_no_write_barrier(heap->raw_unchecked_two_pointer_filler_map()); } else { UNREACHABLE(); } -- 2.7.4