Fix store buffer ensure space heuristics.

src/store-buffer.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 124 matching lines @@
       if (heap_->InNewSpace(*reinterpret_cast<Object**>(current))) {
         *write++ = current;
       }
     }
     previous = current;
   }
   old_top_ = write;
 }
 
 
+bool StoreBuffer::SpaceAvailable(intptr_t space_needed) {
+  return old_limit_ - old_top_ >= space_needed;
+}
+
+
 void StoreBuffer::EnsureSpace(intptr_t space_needed) {
   while (old_limit_ - old_top_ < space_needed &&
          old_limit_ < old_reserved_limit_) {
     size_t grow = old_limit_ - old_start_;  // Double size.
     CHECK(old_virtual_memory_->Commit(reinterpret_cast<void*>(old_limit_),
                                       grow * kPointerSize,
                                       false));
     old_limit_ += grow;
   }
 
-  if (old_limit_ - old_top_ >= space_needed) return;
+  if (SpaceAvailable(space_needed)) return;
 
   if (old_buffer_is_filtered_) return;
   ASSERT(may_move_store_buffer_entries_);
   Compact();
 
   old_buffer_is_filtered_ = true;
   bool page_has_scan_on_scavenge_flag = false;
 
   PointerChunkIterator it(heap_);
   MemoryChunk* chunk;
   while ((chunk = it.next()) != NULL) {
     if (chunk->scan_on_scavenge()) page_has_scan_on_scavenge_flag = true;
   }
 
   if (page_has_scan_on_scavenge_flag) {
     Filter(MemoryChunk::SCAN_ON_SCAVENGE);
   }
 
-  // If filtering out the entries from scan_on_scavenge pages got us down to
-  // less than half full, then we are satisfied with that.
-  if (old_limit_ - old_top_ > old_top_ - old_start_) return;
-
+  if (SpaceAvailable(space_needed)) return;
   // Sample 1 entry in 97 and filter out the pages where we estimate that more
   // than 1 in 8 pointers are to new space.
   static const int kSampleFinenesses = 5;
   static const struct Samples {
     int prime_sample_step;
     int threshold;
   } samples[kSampleFinenesses] =  {
     { 97, ((Page::kPageSize / kPointerSize) / 97) / 8 },
     { 23, ((Page::kPageSize / kPointerSize) / 23) / 16 },
     { 7, ((Page::kPageSize / kPointerSize) / 7) / 32 },
     { 3, ((Page::kPageSize / kPointerSize) / 3) / 256 },
     { 1, 0}
   };
-  for (int i = kSampleFinenesses - 1; i >= 0; i--) {
+  for (int i = 0; i < kSampleFinenesses; i++) {
     ExemptPopularPages(samples[i].prime_sample_step, samples[i].threshold);
     // As a last resort we mark all pages as being exempt from the store buffer.
     ASSERT(i != 0 || old_top_ == old_start_);
-    if (old_limit_ - old_top_ > old_top_ - old_start_) return;
+    if (SpaceAvailable(space_needed)) return;
   }
   UNREACHABLE();
 }
 
 
 // Sample the store buffer to see if some pages are taking up a lot of space
 // in the store buffer.
 void StoreBuffer::ExemptPopularPages(int prime_sample_step, int threshold) {
   PointerChunkIterator it(heap_);
   MemoryChunk* chunk;
@@ skipping 483 matching lines @@
   heap_->isolate()->counters()->store_buffer_compactions()->Increment();
   CheckForFullBuffer();
 }
 
 
 void StoreBuffer::CheckForFullBuffer() {
   EnsureSpace(kStoreBufferSize * 2);
 }
 
 } }  // namespace v8::internal