Revert memory saving change due to failures on multithreaded tests

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 487 matching lines @@
   static const int kBodyOffset =
     CODE_POINTER_ALIGN(MAP_POINTER_ALIGN(kHeaderSize + Bitmap::kSize));
 
   // The start offset of the object area in a page. Aligned to both maps and
   // code alignment to be suitable for both.  Also aligned to 32 words because
   // the marking bitmap is arranged in 32 bit chunks.
   static const int kObjectStartAlignment = 32 * kPointerSize;
   static const int kObjectStartOffset = kBodyOffset - 1 +
       (kObjectStartAlignment - (kBodyOffset - 1) % kObjectStartAlignment);
 
-  intptr_t size() const { return size_; }
+  size_t size() const { return size_; }
 
-  void set_size(size_t size) { size_ = size; }
+  void set_size(size_t size) {
+    size_ = size;
+  }
 
   Executability executable() {
     return IsFlagSet(IS_EXECUTABLE) ? EXECUTABLE : NOT_EXECUTABLE;
   }
 
   bool ContainsOnlyData() {
     return IsFlagSet(CONTAINS_ONLY_DATA);
   }
 
   bool InNewSpace() {
@@ skipping 131 matching lines @@
   // Returns the next page in the chain of pages owned by a space.
   inline Page* next_page();
   inline Page* prev_page();
   inline void set_next_page(Page* page);
   inline void set_prev_page(Page* page);
 
   // Returns the start address of the object area in this page.
   Address ObjectAreaStart() { return address() + kObjectStartOffset; }
 
   // Returns the end address (exclusive) of the object area in this page.
-  Address ObjectAreaEnd() { return address() + size(); }
+  Address ObjectAreaEnd() { return address() + Page::kPageSize; }
 
   // Checks whether an address is page aligned.
   static bool IsAlignedToPageSize(Address a) {
     return 0 == (OffsetFrom(a) & kPageAlignmentMask);
   }
 
   // Returns the offset of a given address to this page.
   INLINE(int Offset(Address a)) {
     int offset = static_cast<int>(a - address());
     return offset;
   }
 
   // Returns the address for a given offset to the this page.
   Address OffsetToAddress(int offset) {
     ASSERT_PAGE_OFFSET(offset);
     return address() + offset;
   }
 
-  // Expand the committed area for pages that are small.
-  void CommitMore(intptr_t space_needed);
-
   // ---------------------------------------------------------------------
 
   // Page size in bytes.  This must be a multiple of the OS page size.
   static const int kPageSize = 1 << kPageSizeBits;
 
-  // For a 1Mbyte page grow 64k at a time.
-  static const int kGrowthUnit = 1 << (kPageSizeBits - 4);
-
   // Page size mask.
   static const intptr_t kPageAlignmentMask = (1 << kPageSizeBits) - 1;
 
   // Object area size in bytes.
   static const int kObjectAreaSize = kPageSize - kObjectStartOffset;
 
   // Maximum object size that fits in a page.
   static const int kMaxHeapObjectSize = kObjectAreaSize;
 
   static const int kFirstUsedCell =
@@ skipping 15 matching lines @@
   bool WasSweptPrecisely() { return IsFlagSet(WAS_SWEPT_PRECISELY); }
   bool WasSweptConservatively() { return IsFlagSet(WAS_SWEPT_CONSERVATIVELY); }
   bool WasSwept() { return WasSweptPrecisely() || WasSweptConservatively(); }
 
   void MarkSweptPrecisely() { SetFlag(WAS_SWEPT_PRECISELY); }
   void MarkSweptConservatively() { SetFlag(WAS_SWEPT_CONSERVATIVELY); }
 
   void ClearSweptPrecisely() { ClearFlag(WAS_SWEPT_PRECISELY); }
   void ClearSweptConservatively() { ClearFlag(WAS_SWEPT_CONSERVATIVELY); }
 
-  Address RoundUpToObjectAlignment(Address a);
-
 #ifdef DEBUG
   void Print();
 #endif  // DEBUG
 
   friend class MemoryAllocator;
 };
 
 
 STATIC_CHECK(sizeof(Page) <= MemoryChunk::kHeaderSize);
 
@@ skipping 109 matching lines @@
   Isolate* isolate_;
 
   // The reserved range of virtual memory that all code objects are put in.
   VirtualMemory* code_range_;
   // Plain old data class, just a struct plus a constructor.
   class FreeBlock {
    public:
     FreeBlock(Address start_arg, size_t size_arg)
         : start(start_arg), size(size_arg) {
       ASSERT(IsAddressAligned(start, MemoryChunk::kAlignment));
+      ASSERT(size >= static_cast<size_t>(Page::kPageSize));
     }
     FreeBlock(void* start_arg, size_t size_arg)
         : start(static_cast<Address>(start_arg)), size(size_arg) {
       ASSERT(IsAddressAligned(start, MemoryChunk::kAlignment));
+      ASSERT(size >= static_cast<size_t>(Page::kPageSize));
     }
 
     Address start;
     size_t size;
   };
 
   // Freed blocks of memory are added to the free list.  When the allocation
   // list is exhausted, the free list is sorted and merged to make the new
   // allocation list.
   List<FreeBlock> free_list_;
@@ skipping 75 matching lines @@
 class MemoryAllocator {
  public:
   explicit MemoryAllocator(Isolate* isolate);
 
   // Initializes its internal bookkeeping structures.
   // Max capacity of the total space and executable memory limit.
   bool SetUp(intptr_t max_capacity, intptr_t capacity_executable);
 
   void TearDown();
 
-  Page* AllocatePage(intptr_t object_area_size,
-                     PagedSpace* owner,
-                     Executability executable);
+  Page* AllocatePage(PagedSpace* owner, Executability executable);
 
   LargePage* AllocateLargePage(intptr_t object_size,
                                       Executability executable,
                                       Space* owner);
 
   void Free(MemoryChunk* chunk);
 
   // Returns the maximum available bytes of heaps.
-  intptr_t Available() {
-    return capacity_ < memory_allocator_reserved_ ?
-           0 :
-           capacity_ - memory_allocator_reserved_;
-  }
+  intptr_t Available() { return capacity_ < size_ ? 0 : capacity_ - size_; }
 
   // Returns allocated spaces in bytes.
-  intptr_t Size() { return memory_allocator_reserved_; }
+  intptr_t Size() { return size_; }
 
   // Returns the maximum available executable bytes of heaps.
   intptr_t AvailableExecutable() {
     if (capacity_executable_ < size_executable_) return 0;
     return capacity_executable_ - size_executable_;
   }
 
   // Returns allocated executable spaces in bytes.
   intptr_t SizeExecutable() { return size_executable_; }
 
   // Returns maximum available bytes that the old space can have.
   intptr_t MaxAvailable() {
     return (Available() / Page::kPageSize) * Page::kObjectAreaSize;
   }
 
 #ifdef DEBUG
   // Reports statistic info of the space.
   void ReportStatistics();
 #endif
 
   MemoryChunk* AllocateChunk(intptr_t body_size,
-                             intptr_t committed_body_size,
                              Executability executable,
                              Space* space);
 
   Address ReserveAlignedMemory(size_t requested,
                                size_t alignment,
                                VirtualMemory* controller);
   Address AllocateAlignedMemory(size_t requested,
-                                size_t committed,
                                 size_t alignment,
                                 Executability executable,
                                 VirtualMemory* controller);
 
   void FreeMemory(VirtualMemory* reservation, Executability executable);
   void FreeMemory(Address addr, size_t size, Executability executable);
 
   // Commit a contiguous block of memory from the initial chunk.  Assumes that
   // the address is not NULL, the size is greater than zero, and that the
   // block is contained in the initial chunk.  Returns true if it succeeded
   // and false otherwise.
   bool CommitBlock(Address start, size_t size, Executability executable);
 
   // Uncommit a contiguous block of memory [start..(start+size)[.
   // start is not NULL, the size is greater than zero, and the
   // block is contained in the initial chunk.  Returns true if it succeeded
   // and false otherwise.
   bool UncommitBlock(Address start, size_t size);
 
-  void AllocationBookkeeping(Space* owner,
-                             Address base,
-                             intptr_t reserved_size,
-                             intptr_t committed_size,
-                             Executability executable);
-
   // Zaps a contiguous block of memory [start..(start+size)[ thus
   // filling it up with a recognizable non-NULL bit pattern.
   void ZapBlock(Address start, size_t size);
 
   void PerformAllocationCallback(ObjectSpace space,
                                  AllocationAction action,
                                  size_t size);
 
   void AddMemoryAllocationCallback(MemoryAllocationCallback callback,
                                           ObjectSpace space,
                                           AllocationAction action);
 
   void RemoveMemoryAllocationCallback(
       MemoryAllocationCallback callback);
 
   bool MemoryAllocationCallbackRegistered(
       MemoryAllocationCallback callback);
 
  private:
   Isolate* isolate_;
 
   // Maximum space size in bytes.
   size_t capacity_;
   // Maximum subset of capacity_ that can be executable
   size_t capacity_executable_;
 
   // Allocated space size in bytes.
-  size_t memory_allocator_reserved_;
+  size_t size_;
   // Allocated executable space size in bytes.
   size_t size_executable_;
 
   struct MemoryAllocationCallbackRegistration {
     MemoryAllocationCallbackRegistration(MemoryAllocationCallback callback,
                                          ObjectSpace space,
                                          AllocationAction action)
         : callback(callback), space(space), action(action) {
     }
     MemoryAllocationCallback callback;
@@ skipping 324 matching lines @@
 
   void CountFreeListItems(Page* p, SizeStats* sizes);
 
   intptr_t EvictFreeListItems(Page* p);
 
  private:
   // The size range of blocks, in bytes.
   static const int kMinBlockSize = 3 * kPointerSize;
   static const int kMaxBlockSize = Page::kMaxHeapObjectSize;
 
-  FreeListNode* PickNodeFromList(FreeListNode** list,
-                                 int* node_size,
-                                 int minimum_size);
+  FreeListNode* PickNodeFromList(FreeListNode** list, int* node_size);
 
-  FreeListNode* FindNodeFor(int size_in_bytes, int* node_size, Address limit);
-  FreeListNode* FindAbuttingNode(int size_in_bytes,
-                                 int* node_size,
-                                 Address limit,
-                                 FreeListNode** list_head);
+  FreeListNode* FindNodeFor(int size_in_bytes, int* node_size);
 
   PagedSpace* owner_;
   Heap* heap_;
 
   // Total available bytes in all blocks on this free list.
   int available_;
 
   static const int kSmallListMin = 0x20 * kPointerSize;
   static const int kSmallListMax = 0xff * kPointerSize;
   static const int kMediumListMax = 0x7ff * kPointerSize;
@@ skipping 79 matching lines @@
   virtual intptr_t SizeOfObjects() {
     ASSERT(!IsSweepingComplete() || (unswept_free_bytes_ == 0));
     return Size() - unswept_free_bytes_ - (limit() - top());
   }
 
   // Wasted bytes in this space.  These are just the bytes that were thrown away
   // due to being too small to use for allocation.  They do not include the
   // free bytes that were not found at all due to lazy sweeping.
   virtual intptr_t Waste() { return accounting_stats_.Waste(); }
 
-  virtual int ObjectAlignment() { return kObjectAlignment; }
-
   // Returns the allocation pointer in this space.
   Address top() { return allocation_info_.top; }
   Address limit() { return allocation_info_.limit; }
 
   // Allocate the requested number of bytes in the space if possible, return a
   // failure object if not.
   MUST_USE_RESULT inline MaybeObject* AllocateRaw(int size_in_bytes);
 
   virtual bool ReserveSpace(int bytes);
 
   // Give a block of memory to the space's free list.  It might be added to
   // the free list or accounted as waste.
   // If add_to_freelist is false then just accounting stats are updated and
   // no attempt to add area to free list is made.
-  int AddToFreeLists(Address start, int size_in_bytes) {
+  int Free(Address start, int size_in_bytes) {
     int wasted = free_list_.Free(start, size_in_bytes);
     accounting_stats_.DeallocateBytes(size_in_bytes - wasted);
     return size_in_bytes - wasted;
   }
 
   // Set space allocation info.
   void SetTop(Address top, Address limit) {
-    ASSERT(top == NULL || top >= Page::FromAddress(top - 1)->ObjectAreaStart());
     ASSERT(top == limit ||
            Page::FromAddress(top) == Page::FromAddress(limit - 1));
     allocation_info_.top = top;
     allocation_info_.limit = limit;
   }
 
   void Allocate(int bytes) {
     accounting_stats_.AllocateBytes(bytes);
   }
 
@@ skipping 46 matching lines @@
     if (first == &anchor_) first = NULL;
     first_unswept_page_ = first;
   }
 
   void IncrementUnsweptFreeBytes(int by) {
     unswept_free_bytes_ += by;
   }
 
   void IncreaseUnsweptFreeBytes(Page* p) {
     ASSERT(ShouldBeSweptLazily(p));
-    unswept_free_bytes_ +=
-        (p->ObjectAreaEnd() - p->ObjectAreaStart()) - p->LiveBytes();
+    unswept_free_bytes_ += (Page::kObjectAreaSize - p->LiveBytes());
   }
 
   void DecreaseUnsweptFreeBytes(Page* p) {
     ASSERT(ShouldBeSweptLazily(p));
-    unswept_free_bytes_ -=
-        (p->ObjectAreaEnd() - p->ObjectAreaStart() - p->LiveBytes());
+    unswept_free_bytes_ -= (Page::kObjectAreaSize - p->LiveBytes());
   }
 
   bool AdvanceSweeper(intptr_t bytes_to_sweep);
 
   bool IsSweepingComplete() {
     return !first_unswept_page_->is_valid();
   }
 
-  inline bool HasAPage() { return anchor_.next_page() != &anchor_; }
   Page* FirstPage() { return anchor_.next_page(); }
   Page* LastPage() { return anchor_.prev_page(); }
 
   // Returns zero for pages that have so little fragmentation that it is not
   // worth defragmenting them.  Otherwise a positive integer that gives an
   // estimate of fragmentation on an arbitrary scale.
   int Fragmentation(Page* p) {
     FreeList::SizeStats sizes;
     free_list_.CountFreeListItems(p, &sizes);
 
-    intptr_t object_area_size = p->ObjectAreaEnd() - p->ObjectAreaStart();
-
     intptr_t ratio;
     intptr_t ratio_threshold;
     if (identity() == CODE_SPACE) {
       ratio = (sizes.medium_size_ * 10 + sizes.large_size_ * 2) * 100 /
-          object_area_size;
+          Page::kObjectAreaSize;
       ratio_threshold = 10;
     } else {
       ratio = (sizes.small_size_ * 5 + sizes.medium_size_) * 100 /
-          object_area_size;
+          Page::kObjectAreaSize;
       ratio_threshold = 15;
     }
 
     if (FLAG_trace_fragmentation) {
       PrintF("%p [%d]: %d (%.2f%%) %d (%.2f%%) %d (%.2f%%) %d (%.2f%%) %s\n",
              reinterpret_cast<void*>(p),
              identity(),
              static_cast<int>(sizes.small_size_),
              static_cast<double>(sizes.small_size_ * 100) /
-                 object_area_size,
+                 Page::kObjectAreaSize,
              static_cast<int>(sizes.medium_size_),
              static_cast<double>(sizes.medium_size_ * 100) /
-                 object_area_size,
+                 Page::kObjectAreaSize,
              static_cast<int>(sizes.large_size_),
              static_cast<double>(sizes.large_size_ * 100) /
-                 object_area_size,
+                 Page::kObjectAreaSize,
              static_cast<int>(sizes.huge_size_),
              static_cast<double>(sizes.huge_size_ * 100) /
-                 object_area_size,
+                 Page::kObjectAreaSize,
              (ratio > ratio_threshold) ? "[fragmented]" : "");
     }
 
-    if (FLAG_always_compact && sizes.Total() != object_area_size) {
+    if (FLAG_always_compact && sizes.Total() != Page::kObjectAreaSize) {
       return 1;
     }
     if (ratio <= ratio_threshold) return 0;  // Not fragmented.
 
     return static_cast<int>(ratio - ratio_threshold);
   }
 
   void EvictEvacuationCandidatesFromFreeLists();
 
   bool CanExpand();
@@ skipping 10 matching lines @@
 
   // The dummy page that anchors the double linked list of pages.
   Page anchor_;
 
   // The space's free list.
   FreeList free_list_;
 
   // Normal allocation information.
   AllocationInfo allocation_info_;
 
+  // Bytes of each page that cannot be allocated.  Possibly non-zero
+  // for pages in spaces with only fixed-size objects.  Always zero
+  // for pages in spaces with variable sized objects (those pages are
+  // padded with free-list nodes).
+  int page_extra_;
+
   bool was_swept_conservatively_;
 
   // The first page to be swept when the lazy sweeper advances. Is set
   // to NULL when all pages have been swept.
   Page* first_unswept_page_;
 
   // The number of free bytes which could be reclaimed by advancing the
   // lazy sweeper.  This is only an estimation because lazy sweeping is
   // done conservatively.
   intptr_t unswept_free_bytes_;
 
-  // Expands the space by allocating a page. Returns false if it cannot
-  // allocate a page from OS, or if the hard heap size limit has been hit.  The
-  // new page will have at least enough committed space to satisfy the object
-  // size indicated by the allocation_size argument;
-  bool Expand(intptr_t allocation_size);
+  // Expands the space by allocating a fixed number of pages. Returns false if
+  // it cannot allocate requested number of pages from OS, or if the hard heap
+  // size limit has been hit.
+  bool Expand();
 
   // Generic fast case allocation function that tries linear allocation at the
   // address denoted by top in allocation_info_.
   inline HeapObject* AllocateLinearly(int size_in_bytes);
 
   // Slow path of AllocateRaw.  This function is space-dependent.
   MUST_USE_RESULT virtual HeapObject* SlowAllocateRaw(int size_in_bytes);
 
   friend class PageIterator;
 };
@@ skipping 134 matching lines @@
  public:
   // Constructor.
   SemiSpace(Heap* heap, SemiSpaceId semispace)
     : Space(heap, NEW_SPACE, NOT_EXECUTABLE),
       start_(NULL),
       age_mark_(NULL),
       id_(semispace),
       anchor_(this),
       current_page_(NULL) { }
 
-  // Sets up the semispace using the given chunk.  After this, call Commit()
-  // to make the semispace usable.
+  // Sets up the semispace using the given chunk.
   void 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; }
 
   // Grow the semispace to the new capacity.  The new capacity
@@ skipping 484 matching lines @@
 // Old object space (excluding map objects)
 
 class OldSpace : public PagedSpace {
  public:
   // Creates an old space object with a given maximum capacity.
   // The constructor does not allocate pages from OS.
   OldSpace(Heap* heap,
            intptr_t max_capacity,
            AllocationSpace id,
            Executability executable)
-      : PagedSpace(heap, max_capacity, id, executable) { }
+      : PagedSpace(heap, max_capacity, id, executable) {
+    page_extra_ = 0;
+  }
+
+  // The limit of allocation for a page in this space.
+  virtual Address PageAllocationLimit(Page* page) {
+    return page->ObjectAreaEnd();
+  }
 
  public:
   TRACK_MEMORY("OldSpace")
 };
 
 
 // For contiguous spaces, top should be in the space (or at the end) and limit
 // should be the end of the space.
 #define ASSERT_SEMISPACE_ALLOCATION_INFO(info, space) \
   SLOW_ASSERT((space).page_low() <= (info).top             \
               && (info).top <= (space).page_high()         \
               && (info).limit <= (space).page_high())
 
 
 // -----------------------------------------------------------------------------
 // Old space for objects of a fixed size
 
 class FixedSpace : public PagedSpace {
  public:
   FixedSpace(Heap* heap,
              intptr_t max_capacity,
              AllocationSpace id,
              int object_size_in_bytes,
              const char* name)
       : PagedSpace(heap, max_capacity, id, NOT_EXECUTABLE),
         object_size_in_bytes_(object_size_in_bytes),
-        name_(name) { }
+        name_(name) {
+    page_extra_ = Page::kObjectAreaSize % object_size_in_bytes;
+  }
+
+  // The limit of allocation for a page in this space.
+  virtual Address PageAllocationLimit(Page* page) {
+    return page->ObjectAreaEnd() - page_extra_;
+  }
 
   int object_size_in_bytes() { return object_size_in_bytes_; }
 
-  virtual int ObjectAlignment() { return object_size_in_bytes_; }
-
   // Prepares for a mark-compact GC.
   virtual void PrepareForMarkCompact();
 
  protected:
   void ResetFreeList() {
     free_list_.Reset();
   }
 
  private:
   // The size of objects in this space.
@@ skipping 260 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_