Access old space marking bits from runtime only when incremental marking is in MARKING state.

src/objects.cc

 // Copyright 2013 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:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 1283 matching lines @@
                 ? heap->external_string_with_one_byte_data_map()
                 : heap->external_string_map()));
   }
   ExternalTwoByteString* self = ExternalTwoByteString::cast(this);
   self->set_resource(resource);
   if (is_internalized) self->Hash();  // Force regeneration of the hash value.
 
   // Fill the remainder of the string with dead wood.
   int new_size = this->Size();  // Byte size of the external String object.
   heap->CreateFillerObjectAt(this->address() + new_size, size - new_size);
-  if (Marking::IsBlack(Marking::MarkBitFrom(this))) {
+  if (heap->incremental_marking()->IsMarking() &&
+      Marking::IsBlack(Marking::MarkBitFrom(this))) {
     MemoryChunk::IncrementLiveBytesFromMutator(this->address(),
                                                new_size - size);
   }
   return true;
 }
 
 
 bool String::MakeExternal(v8::String::ExternalAsciiStringResource* resource) {
 #ifdef ENABLE_SLOW_ASSERTS
   if (FLAG_enable_slow_asserts) {
@@ skipping 38 matching lines @@
         is_internalized ? heap->external_ascii_internalized_string_map()
                         : heap->external_ascii_string_map());
   }
   ExternalAsciiString* self = ExternalAsciiString::cast(this);
   self->set_resource(resource);
   if (is_internalized) self->Hash();  // Force regeneration of the hash value.
 
   // Fill the remainder of the string with dead wood.
   int new_size = this->Size();  // Byte size of the external String object.
   heap->CreateFillerObjectAt(this->address() + new_size, size - new_size);
-  if (Marking::IsBlack(Marking::MarkBitFrom(this))) {
+  if (heap->incremental_marking()->IsMarking() &&
+      Marking::IsBlack(Marking::MarkBitFrom(this))) {
     MemoryChunk::IncrementLiveBytesFromMutator(this->address(),
                                                new_size - size);
   }
   return true;
 }
 
 
 void String::StringShortPrint(StringStream* accumulator) {
   int len = length();
   if (len > kMaxShortPrintLength) {
@@ skipping 895 matching lines @@
   // If we are doing a big trim in old space then we zap the space.
   Object** zap = reinterpret_cast<Object**>(new_end);
   zap++;  // Header of filler must be at least one word so skip that.
   for (int i = 1; i < to_trim; i++) {
     *zap++ = Smi::FromInt(0);
   }
 }
 
 
 template<RightTrimMode trim_mode>
 static void RightTrimFixedArray(Heap* heap, FixedArray* elms, int to_trim) {

[Michael Starzinger, 2014/03/19 09:30:35]

As discussed offline: There also is access to the mark-bits in
LeftTrimFixedArray. The access is well hidden in Heap::TransferMark(), where we
also need to do an early return if incremental marking is not running.

[Hannes Payer (out of office), 2014/03/19 11:27:51]

Done.

   ASSERT(elms->map() != heap->fixed_cow_array_map());
   // For now this trick is only applied to fixed arrays in new and paged space.
   ASSERT(!heap->lo_space()->Contains(elms));
 
   const int len = elms->length();
 
   ASSERT(to_trim < len);
 
   Address new_end = elms->address() + FixedArray::SizeFor(len - to_trim);
 
   if (trim_mode != FROM_GC || Heap::ShouldZapGarbage()) {
     ZapEndOfFixedArray(new_end, to_trim);
   }
 
   int size_delta = to_trim * kPointerSize;
 
   // Technically in new space this write might be omitted (except for
   // debug mode which iterates through the heap), but to play safer
   // we still do it.
   heap->CreateFillerObjectAt(new_end, size_delta);
 
   elms->set_length(len - to_trim);
 
   // Maintain marking consistency for IncrementalMarking.
-  if (Marking::IsBlack(Marking::MarkBitFrom(elms))) {
+  if (heap->incremental_marking()->IsMarking() &&
+      Marking::IsBlack(Marking::MarkBitFrom(elms))) {

[Michael Starzinger, 2014/03/19 09:30:35]

As discussed offline: I am not sure distinguishing between friends of "Marking"
or not will help, because it mainly depends on the call-path leading there, not
so much the call-site

Another proposal would be to factor our this general logic for adjusting live
bytes into a Heap::AdjustLiveBytes() helper that would take care of checking the
proper pre-conditions. The RightTrimMode would probably need to be renamed to
something like LiveBytesAdjustmentMode.

[Hannes Payer (out of office), 2014/03/19 11:27:51]

Done.

     if (trim_mode == FROM_GC) {
       MemoryChunk::IncrementLiveBytesFromGC(elms->address(), -size_delta);
     } else {
       MemoryChunk::IncrementLiveBytesFromMutator(elms->address(), -size_delta);
     }
   }
 
   // The array may not be moved during GC,
   // and size has to be adjusted nevertheless.
   HeapProfiler* profiler = heap->isolate()->heap_profiler();
@@ skipping 2321 matching lines @@
   Handle<Map> new_map = NormalizedMapCache::Get(cache, object, mode);
   ASSERT(new_map->is_dictionary_map());
 
   // From here on we cannot fail and we shouldn't GC anymore.
   DisallowHeapAllocation no_allocation;
 
   // Resize the object in the heap if necessary.
   int new_instance_size = new_map->instance_size();
   int instance_size_delta = map->instance_size() - new_instance_size;
   ASSERT(instance_size_delta >= 0);
-  isolate->heap()->CreateFillerObjectAt(object->address() + new_instance_size,
-                                        instance_size_delta);
-  if (Marking::IsBlack(Marking::MarkBitFrom(*object))) {
+  Heap* heap = isolate->heap();
+  heap->CreateFillerObjectAt(object->address() + new_instance_size,
+                             instance_size_delta);
+  if (heap->incremental_marking()->IsMarking() &&
+      Marking::IsBlack(Marking::MarkBitFrom(*object))) {
     MemoryChunk::IncrementLiveBytesFromMutator(object->address(),
                                                -instance_size_delta);
   }
 
   object->set_map(*new_map);
   map->NotifyLeafMapLayoutChange();
 
   object->set_properties(*dictionary);
 
   isolate->counters()->props_to_dictionary()->Increment();
@@ skipping 4551 matching lines @@
   NewSpace* newspace = heap->new_space();
   if (newspace->Contains(start_of_string) &&
       newspace->top() == start_of_string + old_size) {
     // Last allocated object in new space.  Simply lower allocation top.
     newspace->set_top(start_of_string + new_size);
   } else {
     // Sizes are pointer size aligned, so that we can use filler objects
     // that are a multiple of pointer size.
     heap->CreateFillerObjectAt(start_of_string + new_size, delta);
   }
-  if (Marking::IsBlack(Marking::MarkBitFrom(start_of_string))) {
+  if (heap->incremental_marking()->IsMarking() &&
+      Marking::IsBlack(Marking::MarkBitFrom(start_of_string))) {
     MemoryChunk::IncrementLiveBytesFromMutator(start_of_string, -delta);
   }
 
 
   if (new_length == 0) return heap->isolate()->factory()->empty_string();
   return string;
 }
 
 
 uint32_t StringHasher::MakeArrayIndexHash(uint32_t value, int length) {
@@ skipping 7298 matching lines @@
 #define ERROR_MESSAGES_TEXTS(C, T) T,
   static const char* error_messages_[] = {
       ERROR_MESSAGES_LIST(ERROR_MESSAGES_TEXTS)
   };
 #undef ERROR_MESSAGES_TEXTS
   return error_messages_[reason];
 }
 
 
 } }  // namespace v8::internal