After performing scavenge, hint OS that data in from spaces are no more neede...

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 422 matching lines @@
   // 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 the
   // block is contained in the initial chunk.  Returns true if it succeeded
   // and false otherwise.
   static bool UncommitBlock(Address start, size_t size);
 
+  // Give OS a hint that data of this contiguous block of memory are no longer
+  // needed and could be discarded.  This does NOT uncommit the block though.
+  static inline bool ResetBlock(Address start, size_t size,
+                                Executability executable);
+
   // 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 pages is returned in the output parameter
   // allocated_pages.  If the PagedSpace owner is executable and there is
   // a code range, the pages are allocated from the code range.
   static Page* AllocatePages(int requested_pages, int* allocated_pages,
@@ skipping 670 matching lines @@
   // 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();
+  inline bool Reset();
 
 #ifdef DEBUG
   virtual void Print();
   virtual void Verify();
 #endif
 
   // Returns the current capacity of the semi space.
   int Capacity() { return capacity_; }
 
   // Returns the maximum capacity of the semi space.
@@ skipping 239 matching lines @@
   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();
   }
 
+  bool ResetFromSpace() {
+    return from_space_.Reset();
+  }
+
  private:
   // The semispaces.
   SemiSpace to_space_;
   SemiSpace from_space_;
 
   // Start address and bit mask for containment testing.
   Address start_;
   uintptr_t address_mask_;
   uintptr_t object_mask_;
   uintptr_t object_expected_;
@@ skipping 547 matching lines @@
 
  private:
   LargeObjectChunk* current_;
   HeapObjectCallback size_func_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_SPACES_H_