[Isolates] Add heap pointer to all maps and use map->heap() more.

src/heap.cc

 // Copyright 2009 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 70 matching lines @@
       code_range_size_(0),
 #endif
 // Variables set based on semispace_size_ and old_generation_size_ in
 // ConfigureHeap (survived_since_last_expansion_, external_allocation_limit_)
 // Will be 4 * reserved_semispace_size_ to ensure that young
 // generation can be aligned to its size.
       survived_since_last_expansion_(0),
       always_allocate_scope_depth_(0),
       linear_allocation_scope_depth_(0),
       contexts_disposed_(0),
+      new_space_(this),
       old_pointer_space_(NULL),
       old_data_space_(NULL),
       code_space_(NULL),
       map_space_(NULL),
       cell_space_(NULL),
       lo_space_(NULL),
       gc_state_(NOT_IN_GC),
       mc_count_(0),
       ms_count_(0),
       gc_count_(0),
@@ skipping 718 matching lines @@
 
   void VisitPointers(Object** start, Object** end) {
     // Copy all HeapObject pointers in [start, end)
     for (Object** p = start; p < end; p++) ScavengePointer(p);
   }
 
  private:
   void ScavengePointer(Object** p) {
     Object* object = *p;
     if (!HEAP->InNewSpace(object)) return;
-    HEAP->ScavengeObject(reinterpret_cast<HeapObject**>(p),
+    Heap::ScavengeObject(reinterpret_cast<HeapObject**>(p),
                          reinterpret_cast<HeapObject*>(object));
   }
 };
 
 
 #ifdef DEBUG
 // Visitor class to verify pointers in code or data space do not point into
 // new space.
 class VerifyNonPointerSpacePointersVisitor: public ObjectVisitor {
  public:
@@ skipping 93 matching lines @@
   promotion_queue_.Initialize(new_space_.ToSpaceHigh());
 
   is_safe_to_read_maps_ = false;
   ScavengeVisitor scavenge_visitor;
   // Copy roots.
   IterateRoots(&scavenge_visitor, VISIT_ALL_IN_SCAVENGE);
 
   // Copy objects reachable from the old generation.  By definition,
   // there are no intergenerational pointers in code or data spaces.
   IterateDirtyRegions(old_pointer_space_,
-                      &IteratePointersInDirtyRegion,
+                      &Heap::IteratePointersInDirtyRegion,
                       &ScavengePointer,
                       WATERMARK_CAN_BE_INVALID);
 
   IterateDirtyRegions(map_space_,
                       &IteratePointersInDirtyMapsRegion,
                       &ScavengePointer,
                       WATERMARK_CAN_BE_INVALID);
 
   lo_space_->IterateDirtyRegions(&ScavengePointer);
 
@@ skipping 76 matching lines @@
   ASSERT(last <= end);
   external_string_table_.ShrinkNewStrings(static_cast<int>(last - start));
 }
 
 
 class NewSpaceScavenger : public StaticNewSpaceVisitor<NewSpaceScavenger> {
  public:
   static inline void VisitPointer(Object** p) {
     Object* object = *p;
     if (!HEAP->InNewSpace(object)) return;
-    HEAP->ScavengeObject(reinterpret_cast<HeapObject**>(p),
+    Heap::ScavengeObject(reinterpret_cast<HeapObject**>(p),
                          reinterpret_cast<HeapObject*>(object));
   }
 };
 
 
 Address Heap::DoScavenge(ObjectVisitor* scavenge_visitor,
                          Address new_space_front) {
   do {
     ASSERT(new_space_front <= new_space_.top());
 
@@ skipping 69 matching lines @@
   static inline void Scavenge(Map* map, HeapObject** slot, HeapObject* obj) {
     table_.GetVisitor(map)(map, slot, obj);
   }
 
 
  private:
   enum ObjectContents  { DATA_OBJECT, POINTER_OBJECT };
   enum SizeRestriction { SMALL, UNKNOWN_SIZE };
 
 #if defined(DEBUG) || defined(ENABLE_LOGGING_AND_PROFILING)
-  static void RecordCopiedObject(HeapObject* obj) {
+  static void RecordCopiedObject(Heap* heap, HeapObject* obj) {
     bool should_record = false;
 #ifdef DEBUG
     should_record = FLAG_heap_stats;
 #endif
 #ifdef ENABLE_LOGGING_AND_PROFILING
     should_record = should_record || FLAG_log_gc;
 #endif
     if (should_record) {
-      if (HEAP->new_space()->Contains(obj)) {
-        HEAP->new_space()->RecordAllocation(obj);
+      if (heap->new_space()->Contains(obj)) {
+        heap->new_space()->RecordAllocation(obj);
       } else {
-        HEAP->new_space()->RecordPromotion(obj);
+        heap->new_space()->RecordPromotion(obj);
       }
     }
   }
 #endif  // defined(DEBUG) || defined(ENABLE_LOGGING_AND_PROFILING)
 
   // Helper function used by CopyObject to copy a source object to an
   // allocated target object and update the forwarding pointer in the source
   // object.  Returns the target object.
-  INLINE(static HeapObject* MigrateObject(HeapObject* source,
+  INLINE(static HeapObject* MigrateObject(Heap* heap,
+                                          HeapObject* source,
                                           HeapObject* target,
                                           int size)) {
     // Copy the content of source to target.
-    HEAP->CopyBlock(target->address(), source->address(), size);
+    heap->CopyBlock(target->address(), source->address(), size);
 
     // Set the forwarding address.
     source->set_map_word(MapWord::FromForwardingAddress(target));
 
 #if defined(DEBUG) || defined(ENABLE_LOGGING_AND_PROFILING)
     // Update NewSpace stats if necessary.
-    RecordCopiedObject(target);
+    RecordCopiedObject(heap, target);
 #endif
-    HEAP_PROFILE(ObjectMoveEvent(source->address(), target->address()));
+    HEAP_PROFILE(heap, ObjectMoveEvent(source->address(), target->address()));
 
     return target;
   }
 
 
   template<ObjectContents object_contents, SizeRestriction size_restriction>
   static inline void EvacuateObject(Map* map,
                                     HeapObject** slot,
                                     HeapObject* object,
                                     int object_size) {
     ASSERT((size_restriction != SMALL) ||
            (object_size <= Page::kMaxHeapObjectSize));
     ASSERT(object->Size() == object_size);
 
-    if (HEAP->ShouldBePromoted(object->address(), object_size)) {
+    if (map->heap()->ShouldBePromoted(object->address(), object_size)) {

[Vitaly Repeshko, 2010/09/10 12:35:25]

We clearly need "heap" as a local variable here.

       Object* result;
 
       if ((size_restriction != SMALL) &&
           (object_size > Page::kMaxHeapObjectSize)) {
-        result = HEAP->lo_space()->AllocateRawFixedArray(object_size);
+        result = map->heap()->lo_space()->AllocateRawFixedArray(object_size);
       } else {
         if (object_contents == DATA_OBJECT) {
-          result = HEAP->old_data_space()->AllocateRaw(object_size);
+          result = map->heap()->old_data_space()->AllocateRaw(object_size);
         } else {
-          result = HEAP->old_pointer_space()->AllocateRaw(object_size);
+          result = map->heap()->old_pointer_space()->AllocateRaw(object_size);
         }
       }
 
       if (!result->IsFailure()) {
         HeapObject* target = HeapObject::cast(result);
-        *slot = MigrateObject(object, target, object_size);
+        *slot = MigrateObject(map->heap(), object , target, object_size);
 
         if (object_contents == POINTER_OBJECT) {
-          HEAP->promotion_queue()->insert(target, object_size);
+          map->heap()->promotion_queue()->insert(target, object_size);
         }
 
-        HEAP->tracer()->increment_promoted_objects_size(object_size);
+        map->heap()->tracer()->increment_promoted_objects_size(object_size);
         return;
       }
     }
-    Object* result = HEAP->new_space()->AllocateRaw(object_size);
+    Object* result = map->heap()->new_space()->AllocateRaw(object_size);
     ASSERT(!result->IsFailure());
-    *slot = MigrateObject(object, HeapObject::cast(result), object_size);
+    *slot = MigrateObject(map->heap(), object, HeapObject::cast(result), object_size);

[Vitaly Repeshko, 2010/09/10 12:35:25]

nit: Long line.

     return;
   }
 
 
   static inline void EvacuateFixedArray(Map* map,
                                         HeapObject** slot,
                                         HeapObject* object) {
     int object_size = FixedArray::BodyDescriptor::SizeOf(map, object);
     EvacuateObject<POINTER_OBJECT, UNKNOWN_SIZE>(map,
                                                  slot,
@@ skipping 30 matching lines @@
 
   static inline bool IsShortcutCandidate(int type) {
     return ((type & kShortcutTypeMask) == kShortcutTypeTag);
   }
 
   static inline void EvacuateShortcutCandidate(Map* map,
                                                HeapObject** slot,
                                                HeapObject* object) {
     ASSERT(IsShortcutCandidate(map->instance_type()));
 
-    if (ConsString::cast(object)->unchecked_second() == HEAP->empty_string()) {
+    if (ConsString::cast(object)->unchecked_second() ==
+        map->heap()->empty_string()) {
       HeapObject* first =
           HeapObject::cast(ConsString::cast(object)->unchecked_first());
 
       *slot = first;
 
-      if (!HEAP->InNewSpace(first)) {
+      if (!map->heap()->InNewSpace(first)) {
         object->set_map_word(MapWord::FromForwardingAddress(first));
         return;
       }
 
       MapWord first_word = first->map_word();
       if (first_word.IsForwardingAddress()) {
         HeapObject* target = first_word.ToForwardingAddress();
 
         *slot = target;
         object->set_map_word(MapWord::FromForwardingAddress(target));
@@ skipping 30 matching lines @@
   typedef void (*Callback)(Map* map, HeapObject** slot, HeapObject* object);
 
   static VisitorDispatchTable<Callback> table_;
 };
 
 
 VisitorDispatchTable<ScavengingVisitor::Callback> ScavengingVisitor::table_;
 
 
 void Heap::ScavengeObjectSlow(HeapObject** p, HeapObject* object) {
-  ASSERT(InFromSpace(object));
+  ASSERT(HEAP->InFromSpace(object));
   MapWord first_word = object->map_word();
   ASSERT(!first_word.IsForwardingAddress());
   Map* map = first_word.ToMap();
   ScavengingVisitor::Scavenge(map, p, object);
 }
 
 
-void Heap::ScavengePointer(HeapObject** p) {
-  HEAP->ScavengeObject(p, *p);
-}
-
-
 Object* Heap::AllocatePartialMap(InstanceType instance_type,
                                  int instance_size) {
   Object* result = AllocateRawMap();
   if (result->IsFailure()) return result;
 
   // Map::cast cannot be used due to uninitialized map field.
   reinterpret_cast<Map*>(result)->set_map(raw_unchecked_meta_map());
   reinterpret_cast<Map*>(result)->set_heap(this);
   reinterpret_cast<Map*>(result)->set_instance_type(instance_type);
   reinterpret_cast<Map*>(result)->set_instance_size(instance_size);
   reinterpret_cast<Map*>(result)->set_visitor_id(
         StaticVisitorBase::GetVisitorId(instance_type, instance_size));
   reinterpret_cast<Map*>(result)->set_inobject_properties(0);
   reinterpret_cast<Map*>(result)->set_pre_allocated_property_fields(0);
   reinterpret_cast<Map*>(result)->set_unused_property_fields(0);
   reinterpret_cast<Map*>(result)->set_bit_field(0);
   reinterpret_cast<Map*>(result)->set_bit_field2(0);
   return result;
 }
 
 
 Object* Heap::AllocateMap(InstanceType instance_type, int instance_size) {
   Object* result = AllocateRawMap();
   if (result->IsFailure()) return result;
 
   Map* map = reinterpret_cast<Map*>(result);
   map->set_map(meta_map());
   map->set_heap(this);
   map->set_instance_type(instance_type);
-  reinterpret_cast<Map*>(result)->set_heap(this);
   map->set_visitor_id(
       StaticVisitorBase::GetVisitorId(instance_type, instance_size));
   map->set_prototype(null_value());
   map->set_constructor(null_value());
   map->set_instance_size(instance_size);
   map->set_inobject_properties(0);
   map->set_pre_allocated_property_fields(0);
   map->set_instance_descriptors(empty_descriptor_array());
   map->set_code_cache(empty_fixed_array());
   map->set_unused_property_fields(0);
@@ skipping 2246 matching lines @@
   ASSERT(reinterpret_cast<Object*>(kFromSpaceZapValue)->IsHeapObject());
   for (Address a = new_space_.FromSpaceLow();
        a < new_space_.FromSpaceHigh();
        a += kPointerSize) {
     Memory::Address_at(a) = kFromSpaceZapValue;
   }
 }
 #endif  // DEBUG
 
 
-bool Heap::IteratePointersInDirtyRegion(Address start,
+bool Heap::IteratePointersInDirtyRegion(Heap* heap,
+                                        Address start,
                                         Address end,
                                         ObjectSlotCallback copy_object_func) {
   Address slot_address = start;
   bool pointers_to_new_space_found = false;
 
   while (slot_address < end) {
     Object** slot = reinterpret_cast<Object**>(slot_address);
-    if (HEAP->InNewSpace(*slot)) {
+    if (heap->InNewSpace(*slot)) {
       ASSERT((*slot)->IsHeapObject());
       copy_object_func(reinterpret_cast<HeapObject**>(slot));
-      if (HEAP->InNewSpace(*slot)) {
+      if (heap->InNewSpace(*slot)) {
         ASSERT((*slot)->IsHeapObject());
         pointers_to_new_space_found = true;
       }
     }
     slot_address += kPointerSize;
   }
   return pointers_to_new_space_found;
 }
 
 
@@ skipping 20 matching lines @@
   Address map_address = start;
   bool pointers_to_new_space_found = false;
 
   while (map_address < end) {
     ASSERT(!HEAP->InNewSpace(Memory::Object_at(map_address)));
     ASSERT(Memory::Object_at(map_address)->IsMap());
 
     Address pointer_fields_start = map_address + Map::kPointerFieldsBeginOffset;
     Address pointer_fields_end = map_address + Map::kPointerFieldsEndOffset;
 
-    if (HEAP->IteratePointersInDirtyRegion(pointer_fields_start,
+    if (Heap::IteratePointersInDirtyRegion(HEAP,

[Vitaly Repeshko, 2010/09/10 12:35:25]

Heap lookup can be moved out of the while loop.

+                                           pointer_fields_start,
                                            pointer_fields_end,
                                            copy_object_func)) {
       pointers_to_new_space_found = true;
     }
 
     map_address += Map::kSize;
   }
 
   return pointers_to_new_space_found;
 }
 
 
 bool Heap::IteratePointersInDirtyMapsRegion(
+    Heap* heap,
     Address start,
     Address end,
     ObjectSlotCallback copy_object_func) {
   Address map_aligned_start = MapStartAlign(start);
   Address map_aligned_end   = MapEndAlign(end);
 
   bool contains_pointers_to_new_space = false;
 
   if (map_aligned_start != start) {
     Address prev_map = map_aligned_start - Map::kSize;
     ASSERT(Memory::Object_at(prev_map)->IsMap());
 
     Address pointer_fields_start =
         Max(start, prev_map + Map::kPointerFieldsBeginOffset);
 
     Address pointer_fields_end =
         Min(prev_map + Map::kPointerFieldsEndOffset, end);
 
     contains_pointers_to_new_space =
-      IteratePointersInDirtyRegion(pointer_fields_start,
+      IteratePointersInDirtyRegion(heap,
+                                   pointer_fields_start,
                                    pointer_fields_end,
                                    copy_object_func)
         || contains_pointers_to_new_space;
   }
 
   contains_pointers_to_new_space =
     IteratePointersInDirtyMaps(map_aligned_start,
                                map_aligned_end,
                                copy_object_func)
       || contains_pointers_to_new_space;
 
   if (map_aligned_end != end) {
     ASSERT(Memory::Object_at(map_aligned_end)->IsMap());
 
     Address pointer_fields_start =
         map_aligned_end + Map::kPointerFieldsBeginOffset;
 
     Address pointer_fields_end =
         Min(end, map_aligned_end + Map::kPointerFieldsEndOffset);
 
     contains_pointers_to_new_space =
-      IteratePointersInDirtyRegion(pointer_fields_start,
+      IteratePointersInDirtyRegion(heap,
+                                   pointer_fields_start,
                                    pointer_fields_end,
                                    copy_object_func)
         || contains_pointers_to_new_space;
   }
 
   return contains_pointers_to_new_space;
 }
 
 
 void Heap::IterateAndMarkPointersToFromSpace(Address start,
@@ skipping 41 matching lines @@
   // area_start by Page::kRegionSize.
   Address second_region =
       reinterpret_cast<Address>(
           reinterpret_cast<intptr_t>(area_start + Page::kRegionSize) &
           ~Page::kRegionAlignmentMask);
 
   // Next region might be beyond area_end.
   Address region_end = Min(second_region, area_end);
 
   if (marks & mask) {
-    if (visit_dirty_region(region_start, region_end, copy_object_func)) {
+    if (visit_dirty_region(this, region_start, region_end, copy_object_func)) {
       newmarks |= mask;
     }
   }
   mask <<= 1;
 
   // Iterate subsequent regions which fully lay inside [area_start, area_end[.
   region_start = region_end;
   region_end = region_start + Page::kRegionSize;
 
   while (region_end <= area_end) {
     if (marks & mask) {
-      if (visit_dirty_region(region_start, region_end, copy_object_func)) {
+      if (visit_dirty_region(this,
+                             region_start,
+                             region_end,
+                             copy_object_func)) {
         newmarks |= mask;
       }
     }
 
     region_start = region_end;
     region_end = region_start + Page::kRegionSize;
 
     mask <<= 1;
   }
 
   if (region_start != area_end) {
     // A small piece of area left uniterated because area_end does not coincide
     // with region end. Check whether region covering last part of area is
     // dirty.
     if (marks & mask) {
-      if (visit_dirty_region(region_start, area_end, copy_object_func)) {
+      if (visit_dirty_region(this, region_start, area_end, copy_object_func)) {
         newmarks |= mask;
       }
     }
   }
 
   return newmarks;
 }
 
 
 
@@ skipping 429 matching lines @@
   // Align the pair of semispaces to their size, which must be a power
   // of 2.
   Address new_space_start =
       RoundUp(reinterpret_cast<byte*>(chunk), 2 * reserved_semispace_size_);
   if (!new_space_.Setup(new_space_start, 2 * reserved_semispace_size_)) {
     return false;
   }
 
   // Initialize old pointer space.
   old_pointer_space_ =
-      new OldSpace(max_old_generation_size_, OLD_POINTER_SPACE, NOT_EXECUTABLE);
+      new OldSpace(this,
+                   max_old_generation_size_,
+                   OLD_POINTER_SPACE,
+                   NOT_EXECUTABLE);
   if (old_pointer_space_ == NULL) return false;
   if (!old_pointer_space_->Setup(NULL, 0)) return false;
 
   // Initialize old data space.
   old_data_space_ =
-      new OldSpace(max_old_generation_size_, OLD_DATA_SPACE, NOT_EXECUTABLE);
+      new OldSpace(this,
+                   max_old_generation_size_,
+                   OLD_DATA_SPACE,
+                   NOT_EXECUTABLE);
   if (old_data_space_ == NULL) return false;
   if (!old_data_space_->Setup(NULL, 0)) return false;
 
   // Initialize the code space, set its maximum capacity to the old
   // generation size. It needs executable memory.
   // On 64-bit platform(s), we put all code objects in a 2 GB range of
   // virtual address space, so that they can call each other with near calls.
   if (code_range_size_ > 0) {
     if (!isolate_->code_range()->Setup(code_range_size_)) {
       return false;
     }
   }
 
   code_space_ =
-      new OldSpace(max_old_generation_size_, CODE_SPACE, EXECUTABLE);
+      new OldSpace(this, max_old_generation_size_, CODE_SPACE, EXECUTABLE);
   if (code_space_ == NULL) return false;
   if (!code_space_->Setup(NULL, 0)) return false;
 
   // Initialize map space.
-  map_space_ = new MapSpace(FLAG_use_big_map_space
+  map_space_ = new MapSpace(this, FLAG_use_big_map_space
       ? max_old_generation_size_
       : MapSpace::kMaxMapPageIndex * Page::kPageSize,
       FLAG_max_map_space_pages,
       MAP_SPACE);
   if (map_space_ == NULL) return false;
   if (!map_space_->Setup(NULL, 0)) return false;
 
   // Initialize global property cell space.
-  cell_space_ = new CellSpace(max_old_generation_size_, CELL_SPACE);
+  cell_space_ = new CellSpace(this, max_old_generation_size_, CELL_SPACE);
   if (cell_space_ == NULL) return false;
   if (!cell_space_->Setup(NULL, 0)) return false;
 
   // The large object code space may contain code or data.  We set the memory
   // to be non-executable here for safety, but this means we need to enable it
   // explicitly when allocating large code objects.
-  lo_space_ = new LargeObjectSpace(LO_SPACE);
+  lo_space_ = new LargeObjectSpace(this, LO_SPACE);
   if (lo_space_ == NULL) return false;
   if (!lo_space_->Setup()) return false;
 
   if (create_heap_objects) {
     // Create initial maps.
     if (!CreateInitialMaps()) return false;
     if (!CreateApiObjects()) return false;
 
     // Create initial objects
     if (!CreateInitialObjects()) return false;
@@ skipping 608 matching lines @@
 }
 
 
 void ExternalStringTable::TearDown() {
   new_space_strings_.Free();
   old_space_strings_.Free();
 }
 
 
 } }  // namespace v8::internal