Cardmarking writebarrier.

src/mark-compact.h

 // Copyright 2006-2008 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 23 matching lines @@
 // Callback function, returns whether an object is alive. The heap size
 // of the object is returned in size. It optionally updates the offset
 // to the first live object in the page (only used for old and map objects).
 typedef bool (*IsAliveFunction)(HeapObject* obj, int* size, int* offset);
 
 // Callback function for non-live blocks in the old generation.
 // If add_to_freelist is false then just accounting stats are updated and
 // no attempt to add area to free list is made.
 typedef void (*DeallocateFunction)(Address start,
                                    int size_in_bytes,
-                                   bool add_to_freelist);
+                                   bool add_to_freelist,
+                                   bool last_on_page);
 
 
 // Forward declarations.
 class RootMarkingVisitor;
 class MarkingVisitor;
 
 
 // -------------------------------------------------------------------------
 // Mark-Compact collector
 //
@@ skipping 69 matching lines @@
 
  private:
 #ifdef DEBUG
   enum CollectorState {
     IDLE,
     PREPARE_GC,
     MARK_LIVE_OBJECTS,
     SWEEP_SPACES,
     ENCODE_FORWARDING_ADDRESSES,
     UPDATE_POINTERS,
-    RELOCATE_OBJECTS,
-    REBUILD_RSETS
+    RELOCATE_OBJECTS
   };
 
   // The current stage of the collector.
   static CollectorState state_;
 #endif
 
   // Global flag that forces a compaction.
   static bool force_compaction_;
 
   // Global flag indicating whether spaces were compacted on the last GC.
@@ skipping 116 matching lines @@
   //          list.
   //
   //   After: (Compacting collection.)  The forwarding address of live
   //          objects in the paged spaces is encoded in their map word
   //          along with their (non-forwarded) map pointer.
   //
   //          The forwarding address of live objects in the new space is
   //          written to their map word's offset in the inactive
   //          semispace.
   //
-  //          Bookkeeping data is written to the remembered-set are of
+  //          Bookkeeping data is written to the page header of
   //          eached paged-space page that contains live objects after
   //          compaction:
   //
-  //          The 3rd word of the page (first word of the remembered
-  //          set) contains the relocation top address, the address of
-  //          the first word after the end of the last live object in
-  //          the page after compaction.
+  //          The allocation watermark field is used to track the
+  //          relocation top address, the address of the first word
+  //          after the end of the last live object in the page after
+  //          compaction.
   //
-  //          The 4th word contains the zero-based index of the page in
-  //          its space.  This word is only used for map space pages, in
+  //          The Page::mc_page_index field contains the zero-based index of the
+  //          page in its space.  This word is only used for map space pages, in
   //          order to encode the map addresses in 21 bits to free 11
   //          bits per map word for the forwarding address.
   //
-  //          The 5th word contains the (nonencoded) forwarding address
-  //          of the first live object in the page.
+  //          The Page::mc_first_forwarded field contains the (nonencoded)
+  //          forwarding address of the first live object in the page.
   //
   //          In both the new space and the paged spaces, a linked list
   //          of live regions is constructructed (linked through
   //          pointers in the non-live region immediately following each
   //          live region) to speed further passes of the collector.
 
   // Encodes forwarding addresses of objects in compactable parts of the
   // heap.
   static void EncodeForwardingAddresses();
 
@@ skipping 14 matching lines @@
 
   // Iterates the live objects between a range of addresses, returning the
   // number of live objects.
   static int IterateLiveObjectsInRange(Address start, Address end,
                                        HeapObjectCallback size_func);
 
   // Callback functions for deallocating non-live blocks in the old
   // generation.
   static void DeallocateOldPointerBlock(Address start,
                                         int size_in_bytes,
-                                        bool add_to_freelist);
+                                        bool add_to_freelist,
+                                        bool last_on_page);
 
   static void DeallocateOldDataBlock(Address start,
                                      int size_in_bytes,
-                                     bool add_to_freelist);
+                                     bool add_to_freelist,
+                                     bool last_on_page);
 
   static void DeallocateCodeBlock(Address start,
                                   int size_in_bytes,
-                                  bool add_to_freelist);
+                                  bool add_to_freelist,
+                                  bool last_on_page);
 
   static void DeallocateMapBlock(Address start,
                                  int size_in_bytes,
-                                 bool add_to_freelist);
+                                 bool add_to_freelist,
+                                 bool last_on_page);
 
   static void DeallocateCellBlock(Address start,
                                   int size_in_bytes,
-                                  bool add_to_freelist);
+                                  bool add_to_freelist,
+                                  bool last_on_page);
 
   // If we are not compacting the heap, we simply sweep the spaces except
   // for the large object space, clearing mark bits and adding unmarked
   // regions to each space's free list.
   static void SweepSpaces();
 
   // -----------------------------------------------------------------------
   // Phase 3: Updating pointers in live objects.
   //
   //  Before: Same as after phase 2 (compacting collection).
   //
   //   After: All pointers in live objects, including encoded map
   //          pointers, are updated to point to their target's new
-  //          location.  The remembered set area of each paged-space
-  //          page containing live objects still contains bookkeeping
-  //          information.
+  //          location.
 
   friend class UpdatingVisitor;  // helper for updating visited objects
 
   // Updates pointers in all spaces.
   static void UpdatePointers();
 
   // Updates pointers in an object in new space.
   // Returns the heap size of the object.
   static int UpdatePointersInNewObject(HeapObject* obj);
 
   // Updates pointers in an object in old spaces.
   // Returns the heap size of the object.
   static int UpdatePointersInOldObject(HeapObject* obj);
 
   // Calculates the forwarding address of an object in an old space.
   static Address GetForwardingAddressInOldSpace(HeapObject* obj);
 
   // -----------------------------------------------------------------------
   // Phase 4: Relocating objects.
   //
   //  Before: Pointers to live objects are updated to point to their
-  //          target's new location.  The remembered set area of each
-  //          paged-space page containing live objects still contains
-  //          bookkeeping information.
+  //          target's new location.
   //
-  //   After: Objects have been moved to their new addresses. The
-  //          remembered set area of each paged-space page containing
-  //          live objects still contains bookkeeping information.
+  //   After: Objects have been moved to their new addresses.
 
   // Relocates objects in all spaces.
   static void RelocateObjects();
 
   // Converts a code object's inline target to addresses, convention from
   // address to target happens in the marking phase.
   static int ConvertCodeICTargetToAddress(HeapObject* obj);
 
   // Relocate a map object.
   static int RelocateMapObject(HeapObject* obj);
 
   // Relocates an old object.
   static int RelocateOldPointerObject(HeapObject* obj);
   static int RelocateOldDataObject(HeapObject* obj);
 
   // Relocate a property cell object.
   static int RelocateCellObject(HeapObject* obj);
 
   // Helper function.
   static inline int RelocateOldNonCodeObject(HeapObject* obj,
                                              PagedSpace* space);
 
   // Relocates an object in the code space.
   static int RelocateCodeObject(HeapObject* obj);
 
   // Copy a new object.
   static int RelocateNewObject(HeapObject* obj);
 
-  // -----------------------------------------------------------------------
-  // Phase 5: Rebuilding remembered sets.
-  //
-  //  Before: The heap is in a normal state except that remembered sets
-  //          in the paged spaces are not correct.
-  //
-  //   After: The heap is in a normal state.
-
-  // Rebuild remembered set in old and map spaces.
-  static void RebuildRSets();
-
 #ifdef DEBUG
   // -----------------------------------------------------------------------
   // Debugging variables, functions and classes
   // Counters used for debugging the marking phase of mark-compact or
   // mark-sweep collection.
 
   // Size of live objects in Heap::to_space_.
   static int live_young_objects_size_;
 
   // Size of live objects in Heap::old_pointer_space_.
@@ skipping 22 matching lines @@
 
   friend class UnmarkObjectVisitor;
   static void UnmarkObject(HeapObject* obj);
 #endif
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_MARK_COMPACT_H_