- Added simple memory reduction behavior for IdleNotification....

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 349 matching lines @@
   // greater than zero.
   static Page* CommitPages(Address start, size_t size, PagedSpace* owner,
                            int* num_pages);
 
   // 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.
   static 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 that the

[Mads Ager (chromium), 2009/08/13 12:00:56]

and that the -> and the

+  // block is contained in the initial chunk.  Returns true if it succeeded
+  // and false otherwise.
+  static bool UncommitBlock(Address start, size_t size);
+
   // Attempts to allocate the requested (non-zero) number of pages from the
   // OS.  Fewer pages might be allocated than requested. If it fails to
   // allocate memory for the OS or cannot allocate a single page, this
   // function returns an invalid page pointer (NULL). The caller must check
   // whether the returned page is valid (by calling Page::is_valid()).  It is
   // guaranteed that allocated pages have contiguous addresses.  The actual
   // number of allocated page is returned in the output parameter
   // allocated_pages.
   static Page* AllocatePages(int requested_pages, int* allocated_pages,
                              PagedSpace* owner);
@@ skipping 648 matching lines @@
   // The offset of an address from the beginning of the space.
   int SpaceOffsetForAddress(Address addr) { return addr - low(); }
 
   // If we don't have this here then SemiSpace will be abstract.  However
   // it should never be called.
   virtual int Size() {
     UNREACHABLE();
     return 0;
   }
 
+  bool is_committed() { return committed_; }
+  bool Commit();
+  bool Uncommit();
+
 #ifdef DEBUG
   virtual void Print();
   virtual void Verify();
 #endif
 
   // Returns the current capacity of the semi space.
   int Capacity() { return capacity_; }
 
  private:
   // The current and maximum capacity of the space.
   int capacity_;
   int maximum_capacity_;
 
   // The start address of the space.
   Address start_;
   // 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_;
+
  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
 // semispace) to the top of the semispace.  New objects allocated after the
 // iterator is created are not iterated.
@@ skipping 172 matching lines @@
   // Clears previously collected statistics.
   void ClearHistograms();
 
   // Record the allocation or promotion of a heap object.  Note that we don't
   // record every single allocation, but only those that happen in the
   // to space during a scavenge GC.
   void RecordAllocation(HeapObject* obj);
   void RecordPromotion(HeapObject* obj);
 #endif
 
+  // Return whether the operation succeded.
+  bool CommitFromSpaceIfNeeded() {
+    if (from_space_.is_committed()) return true;
+    return from_space_.Commit();
+  }
+
+  bool UncommitFromSpace() {
+    if (!from_space_.is_committed()) return true;
+    return from_space_.Uncommit();
+  }
+
  private:
   // The current and maximum capacities of a semispace.
   int capacity_;
   int maximum_capacity_;
 
   // The semispaces.
   SemiSpace to_space_;
   SemiSpace from_space_;
 
   // Start address and bit mask for containment testing.
@@ skipping 549 matching lines @@
 
  private:
   LargeObjectChunk* current_;
   HeapObjectCallback size_func_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_SPACES_H_