Reduce signal sender thread stack size to 32k.

src/heap.cc

 // 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 562 matching lines @@
     int map_space_size,
     int cell_space_size,
     int large_object_size) {
   NewSpace* new_space = Heap::new_space();
   PagedSpace* old_pointer_space = Heap::old_pointer_space();
   PagedSpace* old_data_space = Heap::old_data_space();
   PagedSpace* code_space = Heap::code_space();
   PagedSpace* map_space = Heap::map_space();
   PagedSpace* cell_space = Heap::cell_space();
   LargeObjectSpace* lo_space = Heap::lo_space();
+  bool one_gc_has_been_performed = false;
   bool gc_performed = true;
   while (gc_performed) {
     gc_performed = false;
     if (!new_space->ReserveSpace(new_space_size)) {
       Heap::CollectGarbage(NEW_SPACE);
       gc_performed = true;
     }
     if (!old_pointer_space->ReserveSpace(pointer_space_size)) {
       Heap::CollectGarbage(OLD_POINTER_SPACE);
       gc_performed = true;
@@ skipping 15 matching lines @@
       gc_performed = true;
     }
     // We add a slack-factor of 2 in order to have space for a series of
     // large-object allocations that are only just larger than the page size.
     large_object_size *= 2;
     // The ReserveSpace method on the large object space checks how much
     // we can expand the old generation.  This includes expansion caused by
     // allocation in the other spaces.
     large_object_size += cell_space_size + map_space_size + code_space_size +
         data_space_size + pointer_space_size;
-    if (!(lo_space->ReserveSpace(large_object_size))) {
+
+    // If we already did one GC in order to make space in old space, there is
+    // no sense in doing another one.  We will attempt to force through the
+    // large object space allocation, which comes directly from the OS,
+    // regardless of any soft limit.
+    if (!one_gc_has_been_performed &&
+        !(lo_space->ReserveSpace(large_object_size))) {
       Heap::CollectGarbage(LO_SPACE);
       gc_performed = true;
     }
+    if (gc_performed) one_gc_has_been_performed = true;

[Vyacheslav Egorov (Chromium), 2011/12/21 13:22:12]

scavenge will not free any space in LO.

gc_performed does not imply full_gc_performed.

   }
 }
 
 
 void Heap::EnsureFromSpaceIsCommitted() {
   if (new_space_.CommitFromSpaceIfNeeded()) return;
 
   // Committing memory to from space failed.
   // Try shrinking and try again.
   Shrink();
@@ skipping 4662 matching lines @@
   }
 
   // The max executable size must be less than or equal to the max old
   // generation size.
   if (max_executable_size_ > max_old_generation_size_) {
     max_executable_size_ = max_old_generation_size_;
   }
 
   // The new space size must be a power of two to support single-bit testing
   // for containment.
-  max_semispace_size_ = RoundUpToPowerOf2(max_semispace_size_);
-  reserved_semispace_size_ = RoundUpToPowerOf2(reserved_semispace_size_);
+  max_semispace_size_ = SignedRoundUpToPowerOf2(max_semispace_size_);

[Vyacheslav Egorov (Chromium), 2011/12/21 13:22:12]

what's the point of these fields being signed? looks ugly.

+  reserved_semispace_size_ = SignedRoundUpToPowerOf2(reserved_semispace_size_);
   initial_semispace_size_ = Min(initial_semispace_size_, max_semispace_size_);
   external_allocation_limit_ = 10 * max_semispace_size_;
 
   // The old generation is paged and needs at least one page for each space.
   int paged_space_count = LAST_PAGED_SPACE - FIRST_PAGED_SPACE + 1;
   max_old_generation_size_ = Max(static_cast<intptr_t>(paged_space_count *
                                                        Page::kPageSize),
                                  RoundUp(max_old_generation_size_,
                                          Page::kPageSize));
 
@@ skipping 1285 matching lines @@
   isolate_->heap()->store_buffer()->Compact();
   isolate_->heap()->store_buffer()->Filter(MemoryChunk::ABOUT_TO_BE_FREED);
   for (chunk = chunks_queued_for_free_; chunk != NULL; chunk = next) {
     next = chunk->next_chunk();
     isolate_->memory_allocator()->Free(chunk);
   }
   chunks_queued_for_free_ = NULL;
 }
 
 } }  // namespace v8::internal