Reduce boot-up memory use of V8.

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);
 
-  size_t size() const { return size_; }
+  intptr_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() + Page::kPageSize; }
+  Address ObjectAreaEnd() { return address() + size(); }
 
   // 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 144 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(PagedSpace* owner, Executability executable);
+  Page* AllocatePage(intptr_t object_area_size,
+                     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_ < size_ ? 0 : capacity_ - size_; }
+  intptr_t Available() {
+    return capacity_ < memory_allocator_reserved_ ?
+           0 :
+           capacity_ - memory_allocator_reserved_;
+  }
 
   // Returns allocated spaces in bytes.
-  intptr_t Size() { return size_; }
+  intptr_t Size() { return memory_allocator_reserved_; }
 
   // 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 size_;
+  size_t memory_allocator_reserved_;
   // 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);
+  FreeListNode* PickNodeFromList(FreeListNode** list,
+                                 int* node_size,
+                                 int minimum_size);
 
-  FreeListNode* FindNodeFor(int size_in_bytes, 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);
 
   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 Free(Address start, int size_in_bytes) {
+  int AddToFreeLists(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 44 matching lines @@
   void SetPagesToSweep(Page* first) {
     ASSERT(unswept_free_bytes_ == 0);
     if (first == &anchor_) first = NULL;
     first_unswept_page_ = first;
   }
 
   void IncrementUnsweptFreeBytes(int by) {
     unswept_free_bytes_ += by;
   }
 
   void IncreaseUnsweptFreeBytes(Page* p) {

[Vyacheslav Egorov (Chromium), 2012/01/26 16:12:05]

I wonder if this needs to be adjusted somehow to accomodate pages that are
smaller than kObjectAreaSize.

(this is used to provide estimate of SizeOfObjects when lazy sweeping is active.
can lazyly swept pages be partially uncommitted?)

     ASSERT(ShouldBeSweptLazily(p));
     unswept_free_bytes_ += (Page::kObjectAreaSize - p->LiveBytes());
   }
 
   void DecreaseUnsweptFreeBytes(Page* p) {
     ASSERT(ShouldBeSweptLazily(p));
     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);
 
@@ skipping 52 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 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();
+  // 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);
 
   // 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.
+  // Sets up the semispace using the given chunk.  After this, call Commit()
+  // to make the semispace usable.
   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) {
-    page_extra_ = 0;
-  }
-
-  // The limit of allocation for a page in this space.
-  virtual Address PageAllocationLimit(Page* page) {
-    return page->ObjectAreaEnd();
-  }
+      : PagedSpace(heap, max_capacity, id, executable) { }
 
  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) {
-    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_;
-  }
+        name_(name) { }
 
   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_