Check the growth of the old generation before expanding the paged...

src/spaces.cc

 // 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 1512 matching lines @@
 
   // There is no next page in this space.  Try free list allocation.
   int wasted_bytes;
   Object* result = free_list_.Allocate(size_in_bytes, &wasted_bytes);
   accounting_stats_.WasteBytes(wasted_bytes);
   if (!result->IsFailure()) {
     accounting_stats_.AllocateBytes(size_in_bytes);
     return HeapObject::cast(result);
   }
 
-  // Free list allocation failed and there is no next page.  Try to expand
-  // the space and allocate in the new next page.
+  // Free list allocation failed and there is no next page.  Fail if we have
+  // hit the old generation size limit that should cause a garbage
+  // collection.
+  if (Heap::OldGenerationAllocationLimitReached()) {
+    return NULL;
+  }
+
+  // Try to expand the space and allocate in the new next page.
   ASSERT(!current_page->next_page()->is_valid());
   if (Expand(current_page)) {
     return AllocateInNextPage(current_page, size_in_bytes);
   }
 
   // Finally, fail.
   return NULL;
 }
 
 
@@ skipping 457 matching lines @@
   // map space free list implicitly assumes that all free blocks are map
   // sized.
   if (size_in_bytes == Map::kSize) {
     Object* result = free_list_.Allocate();
     if (!result->IsFailure()) {
       accounting_stats_.AllocateBytes(size_in_bytes);
       return HeapObject::cast(result);
     }
   }
 
-  // Free list allocation failed and there is no next page.  Try to expand
-  // the space and allocate in the new next page.
+  // Free list allocation failed and there is no next page.  Fail if we have
+  // hit the old generation size limit that should cause a garbage
+  // collection.
+  if (Heap::OldGenerationAllocationLimitReached()) {
+    return NULL;
+  }
+
+  // Try to expand the space and allocate in the new next page.
   ASSERT(!current_page->next_page()->is_valid());
   if (Expand(current_page)) {
     return AllocateInNextPage(current_page, size_in_bytes);
   }
 
   // Finally, fail.
   return NULL;
 }
 
 
@@ skipping 205 matching lines @@
 
   size_ = 0;
   page_count_ = 0;
 }
 
 
 Object* LargeObjectSpace::AllocateRawInternal(int requested_size,
                                               int object_size,
                                               Executability executable) {
   ASSERT(0 < object_size && object_size <= requested_size);
+
+  // Check if we want to force a GC before growing the old space further.
+  // If so, fail the allocation.
+  if (Heap::OldGenerationAllocationLimitReached()) {
+    return Failure::RetryAfterGC(requested_size, identity());
+  }
+
   size_t chunk_size;
   LargeObjectChunk* chunk =
       LargeObjectChunk::New(requested_size, &chunk_size, executable);
   if (chunk == NULL) {
     return Failure::RetryAfterGC(requested_size, identity());
   }
 
   size_ += chunk_size;
   page_count_++;
   chunk->set_next(first_chunk_);
@@ skipping 269 matching lines @@
                      reinterpret_cast<Object**>(object->address()
                                                 + Page::kObjectAreaSize),
                      allocation_top);
       PrintF("\n");
     }
   }
 }
 #endif  // DEBUG
 
 } }  // namespace v8::internal