if (new_space_.Capacity() < new_space_.MaximumCapacity() &&
survived_since_last_expansion_ > new_space_.Capacity()) {
- // Double the size of new space if there is room to grow and enough
+ // Grow the size of new space if there is room to grow and enough
// data has survived scavenge since the last expansion.
- // TODO(1240712): NewSpace::Double has a return value which is
+ // TODO(1240712): NewSpace::Grow has a return value which is
// ignored here.
- new_space_.Double();
+ new_space_.Grow();
survived_since_last_expansion_ = 0;
}
ASSERT(initial_semispace_capacity <= maximum_semispace_capacity);
ASSERT(IsPowerOf2(maximum_semispace_capacity));
- maximum_capacity_ = maximum_semispace_capacity;
- capacity_ = initial_semispace_capacity;
// Allocate and setup the histogram arrays if necessary.
#if defined(DEBUG) || defined(ENABLE_LOGGING_AND_PROFILING)
#undef SET_NAME
#endif
- ASSERT(size == 2 * maximum_capacity_);
+ ASSERT(size == 2 * maximum_semispace_capacity);
ASSERT(IsAddressAligned(start, size, 0));
- if (!to_space_.Setup(start, capacity_, maximum_capacity_)) {
+ if (!to_space_.Setup(start,
+ initial_semispace_capacity,
+ maximum_semispace_capacity)) {
return false;
}
- if (!from_space_.Setup(start + maximum_capacity_,
- capacity_,
- maximum_capacity_)) {
+ if (!from_space_.Setup(start + maximum_semispace_capacity,
+ initial_semispace_capacity,
+ maximum_semispace_capacity)) {
return false;
}
#endif
start_ = NULL;
- capacity_ = 0;
allocation_info_.top = NULL;
allocation_info_.limit = NULL;
mc_forwarding_info_.top = NULL;
}
-bool NewSpace::Double() {
- ASSERT(capacity_ <= maximum_capacity_ / 2);
+bool NewSpace::Grow() {
+ ASSERT(Capacity() < MaximumCapacity());
// 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_.Double() || !from_space_.Double()) return false;
- capacity_ *= 2;
+ if (!to_space_.Grow() || !from_space_.Grow()) return false;
allocation_info_.limit = to_space_.high();
ASSERT_SEMISPACE_ALLOCATION_INFO(allocation_info_, to_space_);
return true;
}
-bool SemiSpace::Double() {
- if (!MemoryAllocator::CommitBlock(high(), capacity_, executable())) {
+bool SemiSpace::Grow() {
+ // Commit 50% extra space but only up to maximum capacity.
+ int maximum_extra = maximum_capacity_ - capacity_;
+ int extra = Min(RoundUp(capacity_ / 2, OS::AllocateAlignment()),
+ maximum_extra);
+ if (!MemoryAllocator::CommitBlock(high(), extra, executable())) {
return false;
}
- capacity_ *= 2;
+ capacity_ += extra;
return true;
}
// True if the space has been set up but not torn down.
bool HasBeenSetup() { return start_ != NULL; }
- // Double the size of the semispace by committing extra virtual memory.
+ // Grow 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 Double();
+ bool Grow();
// 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_; }
+
+ // Returns the maximum capacity of the semi space.
+ int MaximumCapacity() { return maximum_capacity_; }
+
+
private:
// The current and maximum capacity of the space.
int capacity_;
// Flip the pair of spaces.
void Flip();
- // Doubles the capacity of the semispaces. Assumes that they are not at
+ // Grow the capacity of the semispaces. Assumes that they are not at
// their maximum capacity. Returns a flag indicating success or failure.
- bool Double();
+ bool Grow();
// True if the address or object lies in the address range of either
// semispace (not necessarily below the allocation pointer).
// Return the allocated bytes in the active semispace.
virtual int Size() { return top() - bottom(); }
// Return the current capacity of a semispace.
- int Capacity() { return capacity_; }
+ int Capacity() {
+ ASSERT(to_space_.Capacity() == from_space_.Capacity());
+ return to_space_.Capacity();
+ }
// Return the available bytes without growing in the active semispace.
int Available() { return Capacity() - Size(); }
// Return the maximum capacity of a semispace.
- int MaximumCapacity() { return maximum_capacity_; }
+ int MaximumCapacity() {
+ ASSERT(to_space_.MaximumCapacity() == from_space_.MaximumCapacity());
+ return to_space_.MaximumCapacity();
+ }
// Return the address of the allocation pointer in the active semispace.
Address top() { return allocation_info_.top; }
}
private:
- // The current and maximum capacities of a semispace.
- int capacity_;
- int maximum_capacity_;
-
// The semispaces.
SemiSpace to_space_;
SemiSpace from_space_;