Make InToSpace/InFromSpace use the page header.

src/spaces.h

 // Copyright 2011 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 358 matching lines @@
   }
 
   enum MemoryChunkFlags {
     IS_EXECUTABLE,
     WAS_SWEPT_CONSERVATIVELY,
     CONTAINS_ONLY_DATA,
     POINTERS_TO_HERE_ARE_INTERESTING,
     POINTERS_FROM_HERE_ARE_INTERESTING,
     SCAN_ON_SCAVENGE,
     IN_NEW_SPACE,
+    SEMI_SPACE_TAG,
     NUM_MEMORY_CHUNK_FLAGS
   };
 
   void SetFlag(int flag) {
     flags_ |= 1 << flag;
   }
 
   void ClearFlag(int flag) {
     flags_ &= ~(1 << flag);
   }
 
   bool IsFlagSet(int flag) {
     return (flags_ & (1 << flag)) != 0;
   }
 
-  void CopyFlagsFrom(MemoryChunk* chunk) {
-    flags_ = chunk->flags_;
-  }
-
   static const intptr_t kAlignment = (1 << kPageSizeBits);
 
   static const intptr_t kAlignmentMask = kAlignment - 1;
 
   static const size_t kHeaderSize = kPointerSize + kPointerSize + kPointerSize +
     kPointerSize + kPointerSize + kPointerSize + kPointerSize + kPointerSize;
 
   static const int kBodyOffset =
     CODE_POINTER_ALIGN(MAP_POINTER_ALIGN(kHeaderSize + Bitmap::kSize));
 
@@ skipping 1029 matching lines @@
   HistogramInfo() : NumberAndSizeInfo() {}
 
   const char* name() { return name_; }
   void set_name(const char* name) { name_ = name; }
 
  private:
   const char* name_;
 };
 #endif
 
+// Give numbers to semispaces, so we can see which semispace a newspace
+// page belongs to.
+enum SemiSpaceId {
+  kFirstSemiSpace,
+  kSecondSemiSpace
+};
+
 
 class NewSpacePage : public MemoryChunk {
  public:
   inline NewSpacePage* next_page() const {
     return static_cast<NewSpacePage*>(next_chunk());
   }
 
   inline void set_next_page(NewSpacePage* page) {
     set_next_chunk(page);
   }
+
+  static NewSpacePage* cast(MemoryChunk* page) {
+    ASSERT(page->IsFlagSet(MemoryChunk::IN_NEW_SPACE));
+    return reinterpret_cast<NewSpacePage*>(page);
+  }
+
+  SemiSpaceId GetSemiSpaceId() {
+    return IsFlagSet(MemoryChunk::SEMI_SPACE_TAG) ? kSecondSemiSpace
+                                                  : kFirstSemiSpace;
+  }
+
+  void CopyFlagsFrom(NewSpacePage* chunk) {

[Erik Corry, 2011/05/23 12:58:56]

This is called CopyFlagsFrom, but it only copies one flag.  I think the name
should be singular rather than plural and should include the flag that is
copied.

+    intptr_t semi_space_mask = 1 << MemoryChunk::SEMI_SPACE_TAG;
+    flags_ = (flags_ & semi_space_mask) | (chunk->flags_  & ~(semi_space_mask));
+  }
+
+
  private:
   // Finds the NewSpacePage containg the given address.
   static NewSpacePage* FromAddress(Address address_in_page) {
     Address page_start =
         reinterpret_cast<Address>(reinterpret_cast<uintptr_t>(address_in_page) &
                                   ~Page::kPageAlignmentMask);
     return reinterpret_cast<NewSpacePage*>(page_start);
   }
 
-  static NewSpacePage* Initialize(Heap* heap, Address start);
+  static NewSpacePage* Initialize(Heap* heap, Address start, SemiSpaceId id);
 
   friend class SemiSpace;
   friend class SemiSpaceIterator;
 };
 
 
 // -----------------------------------------------------------------------------
 // SemiSpace in young generation
 //
 // A semispace is a contiguous chunk of memory holding page-like memory
 // chunks. The mark-compact collector  uses the memory of the first page in
 // the from space as a marking stack when tracing live objects.
 
 class SemiSpace : public Space {
  public:
   // Constructor.
-  explicit SemiSpace(Heap* heap) : Space(heap, NEW_SPACE, NOT_EXECUTABLE) {
-    start_ = NULL;
-    age_mark_ = NULL;
-  }
+  SemiSpace(Heap* heap, SemiSpaceId id)
+    : Space(heap, NEW_SPACE, NOT_EXECUTABLE),
+      start_(NULL),
+      age_mark_(NULL),
+      id_(id) { }
 
   // Sets up the semispace using the given chunk.
   bool Setup(Address start, int initial_capacity, int maximum_capacity);
 
   // Tear down the space.  Heap memory was not allocated by the space, so it
   // is not deallocated here.
   void TearDown();
 
   // True if the space has been set up but not torn down.
   bool HasBeenSetup() { return start_ != NULL; }
@@ skipping 31 matching lines @@
   // True if the address is in the address range of this semispace (not
   // necessarily below the allocation pointer).
   bool Contains(Address a) {
     return (reinterpret_cast<uintptr_t>(a) & address_mask_)
            == reinterpret_cast<uintptr_t>(start_);
   }
 
   // True if the object is a heap object in the address range of this
   // semispace (not necessarily below the allocation pointer).
   bool Contains(Object* o) {
-    return (reinterpret_cast<uintptr_t>(o) & object_mask_) == object_expected_;
+    if (o->IsSmi()) {

[Erik Corry, 2011/05/23 12:58:56]

this is SemiSpace::Contains(), but I think what we actually need (perhaps
outside of ASSERTs) is an Object::InFromSpace() and an Object::InToSpace(). 
This can be implemented with one memory read (from the page) rather than two
(one to get the id of the semispace and one to get the bit from the page).  It's
pretty performance critical in scavenging, so I think it's worth the bother of
flipping the bits after a scavenge.

[Lasse Reichstein, 2011/05/24 10:53:42]

Will do. 
That also means that the CopyFlagsFrom function will be changed.

+      return false;
+    }
+    if ((reinterpret_cast<uintptr_t>(o) & ~kHeapObjectTagMask) == 0u) {
+      // A heap-object tagged NULL pointer.
+      return false;
+    }
+    MemoryChunk* page =
+       MemoryChunk::FromAddress(HeapObject::cast(o)->address());
+    return (page->InNewSpace() &&
+            NewSpacePage::cast(page)->GetSemiSpaceId() == id_);
   }
 
   // The offset of an address from the beginning of the space.
   int SpaceOffsetForAddress(Address addr) {
     return static_cast<int>(addr - low());
   }
 
   // If we don't have these here then SemiSpace will be abstract.  However
   // they should never be called.
   virtual intptr_t Size() {
@@ skipping 44 matching lines @@
   // Used to govern object promotion during mark-compact collection.
   Address age_mark_;
 
   // Masks and comparison values to test for containment in this semispace.
   uintptr_t address_mask_;
   uintptr_t object_mask_;
   uintptr_t object_expected_;
 
   bool committed_;
 
+  SemiSpaceId id_;
   NewSpacePage* current_page_;
 
  public:
   TRACK_MEMORY("SemiSpace")
 };
 
 
 // A SemiSpaceIterator is an ObjectIterator that iterates over the active
 // semispace of the heap's new space.  It iterates over the objects in the
 // semispace from a given start address (defaulting to the bottom of the
@@ skipping 47 matching lines @@
 // The young generation space.
 //
 // The new space consists of a contiguous pair of semispaces.  It simply
 // forwards most functions to the appropriate semispace.
 
 class NewSpace : public Space {
  public:
   // Constructor.
   explicit NewSpace(Heap* heap)
     : Space(heap, NEW_SPACE, NOT_EXECUTABLE),
-      to_space_(heap),
-      from_space_(heap) {}
+      to_space_(heap, kFirstSemiSpace),
+      from_space_(heap, kSecondSemiSpace) {}
 
   // Sets up the new space using the given chunk.
   bool Setup(int max_semispace_size);
 
   // Tears down the space.  Heap memory was not allocated by the space, so it
   // is not deallocated here.
   void TearDown();
 
   // True if the space has been set up but not torn down.
   bool HasBeenSetup() {
@@ skipping 606 matching lines @@
   }
   // Must be small, since an iteration is used for lookup.
   static const int kMaxComments = 64;
 };
 #endif
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_SPACES_H_