policy change.
I will put the changes back one at a time so we can see the effect of
them in isolation. Also, there is a bug in the growth policy change
that I will fix before putting it back again.
Review URL: http://codereview.chromium.org/174050
git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@2712
ce2b1a6d-e550-0410-aec6-
3dcde31c8c00
int Heap::old_generation_size_ = 128*MB;
int Heap::initial_semispace_size_ = 128*KB;
#elseif defined(V8_TARGET_ARCH_X64)
-int Heap::semispace_size_ = 8*MB;
+int Heap::semispace_size_ = 16*MB;
int Heap::old_generation_size_ = 1*GB;
int Heap::initial_semispace_size_ = 1*MB;
#else
-int Heap::semispace_size_ = 4*MB;
+int Heap::semispace_size_ = 8*MB;
int Heap::old_generation_size_ = 512*MB;
int Heap::initial_semispace_size_ = 512*KB;
#endif
if (new_space_.Capacity() < new_space_.MaximumCapacity() &&
survived_since_last_expansion_ > new_space_.Capacity()) {
- // Grow the size of new space if there is room to grow and enough
+ // Double the size of new space if there is room to grow and enough
// data has survived scavenge since the last expansion.
- // TODO(1240712): NewSpace::Grow has a return value which is
+ // TODO(1240712): NewSpace::Double has a return value which is
// ignored here.
- new_space_.Grow();
+ new_space_.Double();
survived_since_last_expansion_ = 0;
}
}
-bool NewSpace::Grow() {
- ASSERT(capacity_ < maximum_capacity_);
+bool NewSpace::Double() {
+ ASSERT(capacity_ <= maximum_capacity_ / 2);
// TODO(1240712): Failure to double the from space can result in
// semispaces of different sizes. In the event of that failure, the
// to space doubling should be rolled back before returning false.
- if (!to_space_.Grow() || !from_space_.Grow()) return false;
- capacity_ = to_space_.Capacity() + from_space_.Capacity();
+ if (!to_space_.Double() || !from_space_.Double()) return false;
+ capacity_ *= 2;
allocation_info_.limit = to_space_.high();
ASSERT_SEMISPACE_ALLOCATION_INFO(allocation_info_, to_space_);
return true;
}
-bool SemiSpace::Grow() {
- // Commit 50% extra space but only up to maximum capacity.
- int extra = RoundUp(capacity_ / 2, OS::AllocateAlignment());
- if (capacity_ + extra > maximum_capacity_) {
- extra = maximum_capacity_ - capacity_;
- }
- if (!MemoryAllocator::CommitBlock(high(), extra, executable())) {
+bool SemiSpace::Double() {
+ if (!MemoryAllocator::CommitBlock(high(), capacity_, executable())) {
return false;
}
- capacity_ += extra;
+ capacity_ *= 2;
return true;
}
// True if the space has been set up but not torn down.
bool HasBeenSetup() { return start_ != NULL; }
- // Grow the size of the semispace by committing extra virtual memory.
+ // Double the size of the semispace by committing extra virtual memory.
// Assumes that the caller has checked that the semispace has not reached
// its maximum capacity (and thus there is space available in the reserved
// address range to grow).
- bool Grow();
+ bool Double();
// Returns the start address of the space.
Address low() { return start_; }
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_;
// Flip the pair of spaces.
void Flip();
- // Grow the capacity of the semispaces. Assumes that they are not at
+ // Doubles the capacity of the semispaces. Assumes that they are not at
// their maximum capacity. Returns a flag indicating success or failure.
- bool Grow();
+ bool Double();
// True if the address or object lies in the address range of either
// semispace (not necessarily below the allocation pointer).