X64: Move remembered set to a safe location on x64 platform.

src/spaces.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 75 matching lines @@
 class MemoryAllocator;
 class AllocationInfo;
 
 // -----------------------------------------------------------------------------
 // A page normally has 8K bytes. Large object pages may be larger.  A page
 // address is always aligned to the 8K page size.  A page is divided into
 // three areas: the first two words are used for bookkeeping, the next 248
 // bytes are used as remembered set, and the rest of the page is the object
 // area.
 //
-// Pointers are aligned to the pointer size (4 bytes), only 1 bit is needed
+// Pointers are aligned to the pointer size (4), only 1 bit is needed
 // for a pointer in the remembered set. Given an address, its remembered set
 // bit position (offset from the start of the page) is calculated by dividing
 // its page offset by 32. Therefore, the object area in a page starts at the
 // 256th byte (8K/32). Bytes 0 to 255 do not need the remembered set, so that
 // the first two words (64 bits) in a page can be used for other purposes.
 // TODO(X64): This description only represents the 32-bit layout.
+// On the 64-bit platform, we add an offset to the start of the remembered set.
 //
 // The mark-compact collector transforms a map pointer into a page index and a
 // page offset. The map space can have up to 1024 pages, and 8M bytes (1024 *
 // 8K) in total.  Because a map pointer is aligned to the pointer size (4
 // bytes), 11 bits are enough to encode the page offset. 21 bits (10 for the
 // page index + 11 for the offset in the page) are required to encode a map
 // pointer.
 //
 // The only way to get a page pointer is by calling factory methods:
 //   Page* p = Page::FromAddress(addr); or
@@ skipping 97 matching lines @@
 
   // 8K bytes per page.
   static const int kPageSizeBits = 13;
 
   // Page size in bytes.  This must be a multiple of the OS page size.
   static const int kPageSize = 1 << kPageSizeBits;
 
   // Page size mask.
   static const intptr_t kPageAlignmentMask = (1 << kPageSizeBits) - 1;
 
+  // The offset of the remembered set in a page, in addition to the empty words
+  // formed as the remembered bits of the remembered set itself.
+#ifdef V8_TARGET_ARCH_X64
+  static const int kRSetOffset = 2 * kPointerSize;  // Room for two pointers.

[Lasse Reichstein, 2009/07/01 12:30:18]

Since we have room for it, we might want the RSet to be 32-bit aligned.
Since we don't use the initial part of the Rset (the RSet of the RSet itself),
the actually used part starts 4 bytes later than this, so we could change
kRSetOffset to 28.
But see comment below on lowering the 256 byte object start, which also changes
how many bits we don't use.

+#else
+  static const int kRSetOffset = 0;
+#endif
   // The end offset of the remembered set in a page
   // (heaps are aligned to pointer size).
-  static const int kRSetEndOffset= kPageSize / kBitsPerPointer;
+  static const int kRSetEndOffset = kRSetOffset + kPageSize / kBitsPerPointer;
+
+  // The start offset of the object area in a page.
+#ifdef V8_TARGET_ARCH_X64
+  static const int kObjectStartOffset = 256;

[Lasse Reichstein, 2009/07/01 12:30:18]

We should be able to lower this to 160 and still work.
That requires 126 bytes of RSet, which can fit at position 32 and still be
32-bit aligned.
If we don't care about 32-bit alignment, we can even go down to 144.
Suggested constants:
kObjectStartOffset = 160;
kRsetOffset = 32;  // size 125 (== (8192 - 160) >> 6 )
We can still use the first 2.5 bytes of this RSet for something else if we want.

+#else
+  static const int kObjectStartOffset = kRSetEndOffset;
+#endif
 
   // The start offset of the remembered set in a page.
-  static const int kRSetStartOffset = kRSetEndOffset / kBitsPerPointer;
-
-  // The start offset of the object area in a page.
-  static const int kObjectStartOffset = kRSetEndOffset;
+  static const int kRSetStartOffset = kRSetOffset +
+      kObjectStartOffset / kBitsPerPointer;
 
   // Object area size in bytes.
   static const int kObjectAreaSize = kPageSize - kObjectStartOffset;
 
   // Maximum object size that fits in a page.
   static const int kMaxHeapObjectSize = kObjectAreaSize;
 
   //---------------------------------------------------------------------------
   // Page header description.
   //
@@ skipping 1491 matching lines @@
 
  private:
   LargeObjectChunk* current_;
   HeapObjectCallback size_func_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_SPACES_H_