Use intptr_t instead of int for heap sizes. This is a step towards
removing the 1Gbyte limit. Review URL: http://codereview.chromium.org/3418035 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@5542 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
This commit is contained in:
erik.corry@gmail.com
parent
8f7bfea235
commit
f1635606df
@ -179,8 +179,8 @@ DEFINE_bool(always_inline_smi_code, false,
|
||||
"always inline smi code in non-opt code")
|
||||
|
||||
// heap.cc
|
||||
DEFINE_int(max_new_space_size, 0, "max size of the new generation")
|
||||
DEFINE_int(max_old_space_size, 0, "max size of the old generation")
|
||||
DEFINE_int(max_new_space_size, 0, "max size of the new generation (in kBytes)")
|
||||
DEFINE_int(max_old_space_size, 0, "max size of the old generation (in Mbytes)")
|
||||
DEFINE_bool(gc_global, false, "always perform global GCs")
|
||||
DEFINE_int(gc_interval, -1, "garbage collect after <n> allocations")
|
||||
DEFINE_bool(trace_gc, false,
|
||||
|
||||
86
src/heap.cc
86
src/heap.cc
@ -63,8 +63,8 @@ MapSpace* Heap::map_space_ = NULL;
|
||||
CellSpace* Heap::cell_space_ = NULL;
|
||||
LargeObjectSpace* Heap::lo_space_ = NULL;
|
||||
|
||||
int Heap::old_gen_promotion_limit_ = kMinimumPromotionLimit;
|
||||
int Heap::old_gen_allocation_limit_ = kMinimumAllocationLimit;
|
||||
intptr_t Heap::old_gen_promotion_limit_ = kMinimumPromotionLimit;
|
||||
intptr_t Heap::old_gen_allocation_limit_ = kMinimumAllocationLimit;
|
||||
|
||||
int Heap::old_gen_exhausted_ = false;
|
||||
|
||||
@ -75,17 +75,17 @@ int Heap::amount_of_external_allocated_memory_at_last_global_gc_ = 0;
|
||||
// a multiple of Page::kPageSize.
|
||||
#if defined(ANDROID)
|
||||
int Heap::max_semispace_size_ = 2*MB;
|
||||
int Heap::max_old_generation_size_ = 192*MB;
|
||||
intptr_t Heap::max_old_generation_size_ = 192*MB;
|
||||
int Heap::initial_semispace_size_ = 128*KB;
|
||||
size_t Heap::code_range_size_ = 0;
|
||||
#elif defined(V8_TARGET_ARCH_X64)
|
||||
int Heap::max_semispace_size_ = 16*MB;
|
||||
int Heap::max_old_generation_size_ = 1*GB;
|
||||
intptr_t Heap::max_old_generation_size_ = 1*GB;
|
||||
int Heap::initial_semispace_size_ = 1*MB;
|
||||
size_t Heap::code_range_size_ = 512*MB;
|
||||
#else
|
||||
int Heap::max_semispace_size_ = 8*MB;
|
||||
int Heap::max_old_generation_size_ = 512*MB;
|
||||
intptr_t Heap::max_old_generation_size_ = 512*MB;
|
||||
int Heap::initial_semispace_size_ = 512*KB;
|
||||
size_t Heap::code_range_size_ = 0;
|
||||
#endif
|
||||
@ -108,7 +108,7 @@ HeapObjectCallback Heap::gc_safe_size_of_old_object_ = NULL;
|
||||
// Will be 4 * reserved_semispace_size_ to ensure that young
|
||||
// generation can be aligned to its size.
|
||||
int Heap::survived_since_last_expansion_ = 0;
|
||||
int Heap::external_allocation_limit_ = 0;
|
||||
intptr_t Heap::external_allocation_limit_ = 0;
|
||||
|
||||
Heap::HeapState Heap::gc_state_ = NOT_IN_GC;
|
||||
|
||||
@ -137,10 +137,10 @@ int Heap::allocation_timeout_ = 0;
|
||||
bool Heap::disallow_allocation_failure_ = false;
|
||||
#endif // DEBUG
|
||||
|
||||
int GCTracer::alive_after_last_gc_ = 0;
|
||||
intptr_t GCTracer::alive_after_last_gc_ = 0;
|
||||
double GCTracer::last_gc_end_timestamp_ = 0.0;
|
||||
int GCTracer::max_gc_pause_ = 0;
|
||||
int GCTracer::max_alive_after_gc_ = 0;
|
||||
intptr_t GCTracer::max_alive_after_gc_ = 0;
|
||||
int GCTracer::min_in_mutator_ = kMaxInt;
|
||||
|
||||
int Heap::Capacity() {
|
||||
@ -289,33 +289,46 @@ void Heap::ReportStatisticsBeforeGC() {
|
||||
#if defined(ENABLE_LOGGING_AND_PROFILING)
|
||||
void Heap::PrintShortHeapStatistics() {
|
||||
if (!FLAG_trace_gc_verbose) return;
|
||||
PrintF("Memory allocator, used: %8d, available: %8d\n",
|
||||
PrintF("Memory allocator, used: %8" V8_PTR_PREFIX "d"
|
||||
", available: %8" V8_PTR_PREFIX "d\n",
|
||||
MemoryAllocator::Size(),
|
||||
MemoryAllocator::Available());
|
||||
PrintF("New space, used: %8d, available: %8d\n",
|
||||
PrintF("New space, used: %8" V8_PTR_PREFIX "d"
|
||||
", available: %8" V8_PTR_PREFIX "d\n",
|
||||
Heap::new_space_.Size(),
|
||||
new_space_.Available());
|
||||
PrintF("Old pointers, used: %8d, available: %8d, waste: %8d\n",
|
||||
PrintF("Old pointers, used: %8" V8_PTR_PREFIX "d"
|
||||
", available: %8" V8_PTR_PREFIX "d"
|
||||
", waste: %8" V8_PTR_PREFIX "d\n",
|
||||
old_pointer_space_->Size(),
|
||||
old_pointer_space_->Available(),
|
||||
old_pointer_space_->Waste());
|
||||
PrintF("Old data space, used: %8d, available: %8d, waste: %8d\n",
|
||||
PrintF("Old data space, used: %8" V8_PTR_PREFIX "d"
|
||||
", available: %8" V8_PTR_PREFIX "d"
|
||||
", waste: %8" V8_PTR_PREFIX "d\n",
|
||||
old_data_space_->Size(),
|
||||
old_data_space_->Available(),
|
||||
old_data_space_->Waste());
|
||||
PrintF("Code space, used: %8d, available: %8d, waste: %8d\n",
|
||||
PrintF("Code space, used: %8" V8_PTR_PREFIX "d"
|
||||
", available: %8" V8_PTR_PREFIX "d"
|
||||
", waste: %8" V8_PTR_PREFIX "d\n",
|
||||
code_space_->Size(),
|
||||
code_space_->Available(),
|
||||
code_space_->Waste());
|
||||
PrintF("Map space, used: %8d, available: %8d, waste: %8d\n",
|
||||
PrintF("Map space, used: %8" V8_PTR_PREFIX "d"
|
||||
", available: %8" V8_PTR_PREFIX "d"
|
||||
", waste: %8" V8_PTR_PREFIX "d\n",
|
||||
map_space_->Size(),
|
||||
map_space_->Available(),
|
||||
map_space_->Waste());
|
||||
PrintF("Cell space, used: %8d, available: %8d, waste: %8d\n",
|
||||
PrintF("Cell space, used: %8" V8_PTR_PREFIX "d"
|
||||
", available: %8" V8_PTR_PREFIX "d"
|
||||
", waste: %8" V8_PTR_PREFIX "d\n",
|
||||
cell_space_->Size(),
|
||||
cell_space_->Available(),
|
||||
cell_space_->Waste());
|
||||
PrintF("Large object space, used: %8d, avaialble: %8d\n",
|
||||
PrintF("Large object space, used: %8" V8_PTR_PREFIX "d"
|
||||
", available: %8" V8_PTR_PREFIX "d\n",
|
||||
lo_space_->Size(),
|
||||
lo_space_->Available());
|
||||
}
|
||||
@ -364,8 +377,8 @@ void Heap::GarbageCollectionPrologue() {
|
||||
#endif
|
||||
}
|
||||
|
||||
int Heap::SizeOfObjects() {
|
||||
int total = 0;
|
||||
intptr_t Heap::SizeOfObjects() {
|
||||
intptr_t total = 0;
|
||||
AllSpaces spaces;
|
||||
for (Space* space = spaces.next(); space != NULL; space = spaces.next()) {
|
||||
total += space->Size();
|
||||
@ -962,7 +975,7 @@ void Heap::Scavenge() {
|
||||
DescriptorLookupCache::Clear();
|
||||
|
||||
// Used for updating survived_since_last_expansion_ at function end.
|
||||
int survived_watermark = PromotedSpaceSize();
|
||||
intptr_t survived_watermark = PromotedSpaceSize();
|
||||
|
||||
CheckNewSpaceExpansionCriteria();
|
||||
|
||||
@ -3496,8 +3509,10 @@ void Heap::ReportHeapStatistics(const char* title) {
|
||||
PrintF(">>>>>> =============== %s (%d) =============== >>>>>>\n",
|
||||
title, gc_count_);
|
||||
PrintF("mark-compact GC : %d\n", mc_count_);
|
||||
PrintF("old_gen_promotion_limit_ %d\n", old_gen_promotion_limit_);
|
||||
PrintF("old_gen_allocation_limit_ %d\n", old_gen_allocation_limit_);
|
||||
PrintF("old_gen_promotion_limit_ %" V8_PTR_PREFIX "d\n",
|
||||
old_gen_promotion_limit_);
|
||||
PrintF("old_gen_allocation_limit_ %" V8_PTR_PREFIX "d\n",
|
||||
old_gen_allocation_limit_);
|
||||
|
||||
PrintF("\n");
|
||||
PrintF("Number of handles : %d\n", HandleScope::NumberOfHandles());
|
||||
@ -4069,7 +4084,8 @@ bool Heap::ConfigureHeap(int max_semispace_size, int max_old_gen_size) {
|
||||
|
||||
|
||||
bool Heap::ConfigureHeapDefault() {
|
||||
return ConfigureHeap(FLAG_max_new_space_size / 2, FLAG_max_old_space_size);
|
||||
return ConfigureHeap(
|
||||
FLAG_max_new_space_size * (KB / 2), FLAG_max_old_space_size * MB);
|
||||
}
|
||||
|
||||
|
||||
@ -4111,7 +4127,7 @@ void Heap::RecordStats(HeapStats* stats, bool take_snapshot) {
|
||||
}
|
||||
|
||||
|
||||
int Heap::PromotedSpaceSize() {
|
||||
intptr_t Heap::PromotedSpaceSize() {
|
||||
return old_pointer_space_->Size()
|
||||
+ old_data_space_->Size()
|
||||
+ code_space_->Size()
|
||||
@ -4257,7 +4273,8 @@ void Heap::TearDown() {
|
||||
PrintF("mark_compact_count=%d ", mc_count_);
|
||||
PrintF("max_gc_pause=%d ", GCTracer::get_max_gc_pause());
|
||||
PrintF("min_in_mutator=%d ", GCTracer::get_min_in_mutator());
|
||||
PrintF("max_alive_after_gc=%d ", GCTracer::get_max_alive_after_gc());
|
||||
PrintF("max_alive_after_gc=%" V8_PTR_PREFIX "d ",
|
||||
GCTracer::get_max_alive_after_gc());
|
||||
PrintF("\n\n");
|
||||
}
|
||||
|
||||
@ -4383,7 +4400,9 @@ class PrintHandleVisitor: public ObjectVisitor {
|
||||
public:
|
||||
void VisitPointers(Object** start, Object** end) {
|
||||
for (Object** p = start; p < end; p++)
|
||||
PrintF(" handle %p to %p\n", p, *p);
|
||||
PrintF(" handle %p to %p\n",
|
||||
reinterpret_cast<void*>(p),
|
||||
reinterpret_cast<void*>(*p));
|
||||
}
|
||||
};
|
||||
|
||||
@ -4736,8 +4755,8 @@ void Heap::TracePathToGlobal() {
|
||||
#endif
|
||||
|
||||
|
||||
static int CountTotalHolesSize() {
|
||||
int holes_size = 0;
|
||||
static intptr_t CountTotalHolesSize() {
|
||||
intptr_t holes_size = 0;
|
||||
OldSpaces spaces;
|
||||
for (OldSpace* space = spaces.next();
|
||||
space != NULL;
|
||||
@ -4835,13 +4854,14 @@ GCTracer::~GCTracer() {
|
||||
PrintF("sweepns=%d ", static_cast<int>(scopes_[Scope::MC_SWEEP_NEWSPACE]));
|
||||
PrintF("compact=%d ", static_cast<int>(scopes_[Scope::MC_COMPACT]));
|
||||
|
||||
PrintF("total_size_before=%d ", start_size_);
|
||||
PrintF("total_size_after=%d ", Heap::SizeOfObjects());
|
||||
PrintF("holes_size_before=%d ", in_free_list_or_wasted_before_gc_);
|
||||
PrintF("holes_size_after=%d ", CountTotalHolesSize());
|
||||
PrintF("total_size_before=%" V8_PTR_PREFIX "d ", start_size_);
|
||||
PrintF("total_size_after=%" V8_PTR_PREFIX "d ", Heap::SizeOfObjects());
|
||||
PrintF("holes_size_before=%" V8_PTR_PREFIX "d ",
|
||||
in_free_list_or_wasted_before_gc_);
|
||||
PrintF("holes_size_after=%" V8_PTR_PREFIX "d ", CountTotalHolesSize());
|
||||
|
||||
PrintF("allocated=%d ", allocated_since_last_gc_);
|
||||
PrintF("promoted=%d ", promoted_objects_size_);
|
||||
PrintF("allocated=%" V8_PTR_PREFIX "d ", allocated_since_last_gc_);
|
||||
PrintF("promoted=%" V8_PTR_PREFIX "d ", promoted_objects_size_);
|
||||
|
||||
PrintF("\n");
|
||||
}
|
||||
|
||||
28
src/heap.h
28
src/heap.h
@ -245,7 +245,7 @@ class Heap : public AllStatic {
|
||||
// semi space. The young generation consists of two semi spaces and
|
||||
// we reserve twice the amount needed for those in order to ensure
|
||||
// that new space can be aligned to its size.
|
||||
static int MaxReserved() {
|
||||
static intptr_t MaxReserved() {
|
||||
return 4 * reserved_semispace_size_ + max_old_generation_size_;
|
||||
}
|
||||
static int MaxSemiSpaceSize() { return max_semispace_size_; }
|
||||
@ -269,7 +269,7 @@ class Heap : public AllStatic {
|
||||
static inline int MaxObjectSizeInPagedSpace();
|
||||
|
||||
// Returns of size of all objects residing in the heap.
|
||||
static int SizeOfObjects();
|
||||
static intptr_t SizeOfObjects();
|
||||
|
||||
// Return the starting address and a mask for the new space. And-masking an
|
||||
// address with the mask will result in the start address of the new space
|
||||
@ -1069,7 +1069,7 @@ class Heap : public AllStatic {
|
||||
static int reserved_semispace_size_;
|
||||
static int max_semispace_size_;
|
||||
static int initial_semispace_size_;
|
||||
static int max_old_generation_size_;
|
||||
static intptr_t max_old_generation_size_;
|
||||
static size_t code_range_size_;
|
||||
|
||||
// For keeping track of how much data has survived
|
||||
@ -1098,7 +1098,7 @@ class Heap : public AllStatic {
|
||||
static HeapState gc_state_;
|
||||
|
||||
// Returns the size of object residing in non new spaces.
|
||||
static int PromotedSpaceSize();
|
||||
static intptr_t PromotedSpaceSize();
|
||||
|
||||
// Returns the amount of external memory registered since last global gc.
|
||||
static int PromotedExternalMemorySize();
|
||||
@ -1133,16 +1133,16 @@ class Heap : public AllStatic {
|
||||
// Limit that triggers a global GC on the next (normally caused) GC. This
|
||||
// is checked when we have already decided to do a GC to help determine
|
||||
// which collector to invoke.
|
||||
static int old_gen_promotion_limit_;
|
||||
static intptr_t old_gen_promotion_limit_;
|
||||
|
||||
// Limit that triggers a global GC as soon as is reasonable. This is
|
||||
// checked before expanding a paged space in the old generation and on
|
||||
// every allocation in large object space.
|
||||
static int old_gen_allocation_limit_;
|
||||
static intptr_t old_gen_allocation_limit_;
|
||||
|
||||
// Limit on the amount of externally allocated memory allowed
|
||||
// between global GCs. If reached a global GC is forced.
|
||||
static int external_allocation_limit_;
|
||||
static intptr_t external_allocation_limit_;
|
||||
|
||||
// The amount of external memory registered through the API kept alive
|
||||
// by global handles
|
||||
@ -1837,7 +1837,7 @@ class GCTracer BASE_EMBEDDED {
|
||||
static int get_max_gc_pause() { return max_gc_pause_; }
|
||||
|
||||
// Returns maximum size of objects alive after GC.
|
||||
static int get_max_alive_after_gc() { return max_alive_after_gc_; }
|
||||
static intptr_t get_max_alive_after_gc() { return max_alive_after_gc_; }
|
||||
|
||||
// Returns minimal interval between two subsequent collections.
|
||||
static int get_min_in_mutator() { return min_in_mutator_; }
|
||||
@ -1852,7 +1852,7 @@ class GCTracer BASE_EMBEDDED {
|
||||
}
|
||||
|
||||
double start_time_; // Timestamp set in the constructor.
|
||||
int start_size_; // Size of objects in heap set in constructor.
|
||||
intptr_t start_size_; // Size of objects in heap set in constructor.
|
||||
GarbageCollector collector_; // Type of collector.
|
||||
|
||||
// A count (including this one, eg, the first collection is 1) of the
|
||||
@ -1884,30 +1884,30 @@ class GCTracer BASE_EMBEDDED {
|
||||
|
||||
// Total amount of space either wasted or contained in one of free lists
|
||||
// before the current GC.
|
||||
int in_free_list_or_wasted_before_gc_;
|
||||
intptr_t in_free_list_or_wasted_before_gc_;
|
||||
|
||||
// Difference between space used in the heap at the beginning of the current
|
||||
// collection and the end of the previous collection.
|
||||
int allocated_since_last_gc_;
|
||||
intptr_t allocated_since_last_gc_;
|
||||
|
||||
// Amount of time spent in mutator that is time elapsed between end of the
|
||||
// previous collection and the beginning of the current one.
|
||||
double spent_in_mutator_;
|
||||
|
||||
// Size of objects promoted during the current collection.
|
||||
int promoted_objects_size_;
|
||||
intptr_t promoted_objects_size_;
|
||||
|
||||
// Maximum GC pause.
|
||||
static int max_gc_pause_;
|
||||
|
||||
// Maximum size of objects alive after GC.
|
||||
static int max_alive_after_gc_;
|
||||
static intptr_t max_alive_after_gc_;
|
||||
|
||||
// Minimal interval between two subsequent collections.
|
||||
static int min_in_mutator_;
|
||||
|
||||
// Size of objects alive after last GC.
|
||||
static int alive_after_last_gc_;
|
||||
static intptr_t alive_after_last_gc_;
|
||||
|
||||
static double last_gc_end_timestamp_;
|
||||
};
|
||||
|
||||
@ -270,9 +270,9 @@ void CodeRange::TearDown() {
|
||||
// -----------------------------------------------------------------------------
|
||||
// MemoryAllocator
|
||||
//
|
||||
int MemoryAllocator::capacity_ = 0;
|
||||
int MemoryAllocator::size_ = 0;
|
||||
int MemoryAllocator::size_executable_ = 0;
|
||||
intptr_t MemoryAllocator::capacity_ = 0;
|
||||
intptr_t MemoryAllocator::size_ = 0;
|
||||
intptr_t MemoryAllocator::size_executable_ = 0;
|
||||
|
||||
List<MemoryAllocator::MemoryAllocationCallbackRegistration>
|
||||
MemoryAllocator::memory_allocation_callbacks_;
|
||||
@ -302,7 +302,7 @@ int MemoryAllocator::Pop() {
|
||||
}
|
||||
|
||||
|
||||
bool MemoryAllocator::Setup(int capacity) {
|
||||
bool MemoryAllocator::Setup(intptr_t capacity) {
|
||||
capacity_ = RoundUp(capacity, Page::kPageSize);
|
||||
|
||||
// Over-estimate the size of chunks_ array. It assumes the expansion of old
|
||||
@ -691,7 +691,9 @@ Page* MemoryAllocator::FindLastPageInSameChunk(Page* p) {
|
||||
#ifdef DEBUG
|
||||
void MemoryAllocator::ReportStatistics() {
|
||||
float pct = static_cast<float>(capacity_ - size_) / capacity_;
|
||||
PrintF(" capacity: %d, used: %d, available: %%%d\n\n",
|
||||
PrintF(" capacity: %" V8_PTR_PREFIX "d"
|
||||
", used: %" V8_PTR_PREFIX "d"
|
||||
", available: %%%d\n\n",
|
||||
capacity_, size_, static_cast<int>(pct*100));
|
||||
}
|
||||
#endif
|
||||
@ -769,7 +771,7 @@ Page* MemoryAllocator::RelinkPagesInChunk(int chunk_id,
|
||||
// -----------------------------------------------------------------------------
|
||||
// PagedSpace implementation
|
||||
|
||||
PagedSpace::PagedSpace(int max_capacity,
|
||||
PagedSpace::PagedSpace(intptr_t max_capacity,
|
||||
AllocationSpace id,
|
||||
Executability executable)
|
||||
: Space(id, executable) {
|
||||
@ -1643,7 +1645,8 @@ void NewSpace::ReportStatistics() {
|
||||
#ifdef DEBUG
|
||||
if (FLAG_heap_stats) {
|
||||
float pct = static_cast<float>(Available()) / Capacity();
|
||||
PrintF(" capacity: %d, available: %d, %%%d\n",
|
||||
PrintF(" capacity: %" V8_PTR_PREFIX "d"
|
||||
", available: %" V8_PTR_PREFIX "d, %%%d\n",
|
||||
Capacity(), Available(), static_cast<int>(pct*100));
|
||||
PrintF("\n Object Histogram:\n");
|
||||
for (int i = 0; i <= LAST_TYPE; i++) {
|
||||
@ -2402,7 +2405,9 @@ void PagedSpace::CollectCodeStatistics() {
|
||||
|
||||
void OldSpace::ReportStatistics() {
|
||||
int pct = Available() * 100 / Capacity();
|
||||
PrintF(" capacity: %d, waste: %d, available: %d, %%%d\n",
|
||||
PrintF(" capacity: %" V8_PTR_PREFIX "d"
|
||||
", waste: %" V8_PTR_PREFIX "d"
|
||||
", available: %" V8_PTR_PREFIX "d, %%%d\n",
|
||||
Capacity(), Waste(), Available(), pct);
|
||||
|
||||
ClearHistograms();
|
||||
@ -2559,7 +2564,9 @@ void FixedSpace::DeallocateBlock(Address start,
|
||||
#ifdef DEBUG
|
||||
void FixedSpace::ReportStatistics() {
|
||||
int pct = Available() * 100 / Capacity();
|
||||
PrintF(" capacity: %d, waste: %d, available: %d, %%%d\n",
|
||||
PrintF(" capacity: %" V8_PTR_PREFIX "d"
|
||||
", waste: %" V8_PTR_PREFIX "d"
|
||||
", available: %" V8_PTR_PREFIX "d, %%%d\n",
|
||||
Capacity(), Waste(), Available(), pct);
|
||||
|
||||
ClearHistograms();
|
||||
@ -3011,7 +3018,7 @@ void LargeObjectSpace::Print() {
|
||||
|
||||
|
||||
void LargeObjectSpace::ReportStatistics() {
|
||||
PrintF(" size: %d\n", size_);
|
||||
PrintF(" size: %" V8_PTR_PREFIX "d\n", size_);
|
||||
int num_objects = 0;
|
||||
ClearHistograms();
|
||||
LargeObjectIterator it(this);
|
||||
|
||||
78
src/spaces.h
78
src/spaces.h
@ -371,7 +371,7 @@ class Space : public Malloced {
|
||||
// Identity used in error reporting.
|
||||
AllocationSpace identity() { return id_; }
|
||||
|
||||
virtual int Size() = 0;
|
||||
virtual intptr_t Size() = 0;
|
||||
|
||||
#ifdef ENABLE_HEAP_PROTECTION
|
||||
// Protect/unprotect the space by marking it read-only/writable.
|
||||
@ -491,7 +491,7 @@ class MemoryAllocator : public AllStatic {
|
||||
public:
|
||||
// Initializes its internal bookkeeping structures.
|
||||
// Max capacity of the total space.
|
||||
static bool Setup(int max_capacity);
|
||||
static bool Setup(intptr_t max_capacity);
|
||||
|
||||
// Deletes valid chunks.
|
||||
static void TearDown();
|
||||
@ -582,16 +582,18 @@ class MemoryAllocator : public AllStatic {
|
||||
MemoryAllocationCallback callback);
|
||||
|
||||
// Returns the maximum available bytes of heaps.
|
||||
static int Available() { return capacity_ < size_ ? 0 : capacity_ - size_; }
|
||||
static intptr_t Available() {
|
||||
return capacity_ < size_ ? 0 : capacity_ - size_;
|
||||
}
|
||||
|
||||
// Returns allocated spaces in bytes.
|
||||
static int Size() { return size_; }
|
||||
static intptr_t Size() { return size_; }
|
||||
|
||||
// Returns allocated executable spaces in bytes.
|
||||
static int SizeExecutable() { return size_executable_; }
|
||||
static intptr_t SizeExecutable() { return size_executable_; }
|
||||
|
||||
// Returns maximum available bytes that the old space can have.
|
||||
static int MaxAvailable() {
|
||||
static intptr_t MaxAvailable() {
|
||||
return (Available() / Page::kPageSize) * Page::kObjectAreaSize;
|
||||
}
|
||||
|
||||
@ -649,12 +651,12 @@ class MemoryAllocator : public AllStatic {
|
||||
|
||||
private:
|
||||
// Maximum space size in bytes.
|
||||
static int capacity_;
|
||||
static intptr_t capacity_;
|
||||
|
||||
// Allocated space size in bytes.
|
||||
static int size_;
|
||||
static intptr_t size_;
|
||||
// Allocated executable space size in bytes.
|
||||
static int size_executable_;
|
||||
static intptr_t size_executable_;
|
||||
|
||||
struct MemoryAllocationCallbackRegistration {
|
||||
MemoryAllocationCallbackRegistration(MemoryAllocationCallback callback,
|
||||
@ -927,10 +929,10 @@ class AllocationStats BASE_EMBEDDED {
|
||||
}
|
||||
|
||||
// Accessors for the allocation statistics.
|
||||
int Capacity() { return capacity_; }
|
||||
int Available() { return available_; }
|
||||
int Size() { return size_; }
|
||||
int Waste() { return waste_; }
|
||||
intptr_t Capacity() { return capacity_; }
|
||||
intptr_t Available() { return available_; }
|
||||
intptr_t Size() { return size_; }
|
||||
intptr_t Waste() { return waste_; }
|
||||
|
||||
// Grow the space by adding available bytes.
|
||||
void ExpandSpace(int size_in_bytes) {
|
||||
@ -970,17 +972,19 @@ class AllocationStats BASE_EMBEDDED {
|
||||
}
|
||||
|
||||
private:
|
||||
int capacity_;
|
||||
int available_;
|
||||
int size_;
|
||||
int waste_;
|
||||
intptr_t capacity_;
|
||||
intptr_t available_;
|
||||
intptr_t size_;
|
||||
intptr_t waste_;
|
||||
};
|
||||
|
||||
|
||||
class PagedSpace : public Space {
|
||||
public:
|
||||
// Creates a space with a maximum capacity, and an id.
|
||||
PagedSpace(int max_capacity, AllocationSpace id, Executability executable);
|
||||
PagedSpace(intptr_t max_capacity,
|
||||
AllocationSpace id,
|
||||
Executability executable);
|
||||
|
||||
virtual ~PagedSpace() {}
|
||||
|
||||
@ -1031,21 +1035,21 @@ class PagedSpace : public Space {
|
||||
}
|
||||
|
||||
// Current capacity without growing (Size() + Available() + Waste()).
|
||||
int Capacity() { return accounting_stats_.Capacity(); }
|
||||
intptr_t Capacity() { return accounting_stats_.Capacity(); }
|
||||
|
||||
// Total amount of memory committed for this space. For paged
|
||||
// spaces this equals the capacity.
|
||||
int CommittedMemory() { return Capacity(); }
|
||||
intptr_t CommittedMemory() { return Capacity(); }
|
||||
|
||||
// Available bytes without growing.
|
||||
int Available() { return accounting_stats_.Available(); }
|
||||
intptr_t Available() { return accounting_stats_.Available(); }
|
||||
|
||||
// Allocated bytes in this space.
|
||||
virtual int Size() { return accounting_stats_.Size(); }
|
||||
virtual intptr_t Size() { return accounting_stats_.Size(); }
|
||||
|
||||
// Wasted bytes due to fragmentation and not recoverable until the
|
||||
// next GC of this space.
|
||||
int Waste() { return accounting_stats_.Waste(); }
|
||||
intptr_t Waste() { return accounting_stats_.Waste(); }
|
||||
|
||||
// Returns the address of the first object in this space.
|
||||
Address bottom() { return first_page_->ObjectAreaStart(); }
|
||||
@ -1328,7 +1332,7 @@ class SemiSpace : public Space {
|
||||
|
||||
// If we don't have these here then SemiSpace will be abstract. However
|
||||
// they should never be called.
|
||||
virtual int Size() {
|
||||
virtual intptr_t Size() {
|
||||
UNREACHABLE();
|
||||
return 0;
|
||||
}
|
||||
@ -1354,7 +1358,7 @@ class SemiSpace : public Space {
|
||||
#endif
|
||||
|
||||
// Returns the current capacity of the semi space.
|
||||
int Capacity() { return capacity_; }
|
||||
intptr_t Capacity() { return capacity_; }
|
||||
|
||||
// Returns the maximum capacity of the semi space.
|
||||
int MaximumCapacity() { return maximum_capacity_; }
|
||||
@ -1471,22 +1475,22 @@ class NewSpace : public Space {
|
||||
}
|
||||
|
||||
// Return the allocated bytes in the active semispace.
|
||||
virtual int Size() { return static_cast<int>(top() - bottom()); }
|
||||
virtual intptr_t Size() { return static_cast<int>(top() - bottom()); }
|
||||
|
||||
// Return the current capacity of a semispace.
|
||||
int Capacity() {
|
||||
intptr_t Capacity() {
|
||||
ASSERT(to_space_.Capacity() == from_space_.Capacity());
|
||||
return to_space_.Capacity();
|
||||
}
|
||||
|
||||
// Return the total amount of memory committed for new space.
|
||||
int CommittedMemory() {
|
||||
intptr_t CommittedMemory() {
|
||||
if (from_space_.is_committed()) return 2 * Capacity();
|
||||
return Capacity();
|
||||
}
|
||||
|
||||
// Return the available bytes without growing in the active semispace.
|
||||
int Available() { return Capacity() - Size(); }
|
||||
intptr_t Available() { return Capacity() - Size(); }
|
||||
|
||||
// Return the maximum capacity of a semispace.
|
||||
int MaximumCapacity() {
|
||||
@ -1495,7 +1499,7 @@ class NewSpace : public Space {
|
||||
}
|
||||
|
||||
// Returns the initial capacity of a semispace.
|
||||
int InitialCapacity() {
|
||||
intptr_t InitialCapacity() {
|
||||
ASSERT(to_space_.InitialCapacity() == from_space_.InitialCapacity());
|
||||
return to_space_.InitialCapacity();
|
||||
}
|
||||
@ -1681,7 +1685,7 @@ class OldSpaceFreeList BASE_EMBEDDED {
|
||||
void Reset();
|
||||
|
||||
// Return the number of bytes available on the free list.
|
||||
int available() { return available_; }
|
||||
intptr_t available() { return available_; }
|
||||
|
||||
// Place a node on the free list. The block of size 'size_in_bytes'
|
||||
// starting at 'start' is placed on the free list. The return value is the
|
||||
@ -1783,7 +1787,7 @@ class FixedSizeFreeList BASE_EMBEDDED {
|
||||
void Reset();
|
||||
|
||||
// Return the number of bytes available on the free list.
|
||||
int available() { return available_; }
|
||||
intptr_t available() { return available_; }
|
||||
|
||||
// Place a node on the free list. The block starting at 'start' (assumed to
|
||||
// have size object_size_) is placed on the free list. Bookkeeping
|
||||
@ -1797,7 +1801,7 @@ class FixedSizeFreeList BASE_EMBEDDED {
|
||||
|
||||
private:
|
||||
// Available bytes on the free list.
|
||||
int available_;
|
||||
intptr_t available_;
|
||||
|
||||
// The head of the free list.
|
||||
Address head_;
|
||||
@ -1832,7 +1836,7 @@ class OldSpace : public PagedSpace {
|
||||
|
||||
// The bytes available on the free list (ie, not above the linear allocation
|
||||
// pointer).
|
||||
int AvailableFree() { return free_list_.available(); }
|
||||
intptr_t AvailableFree() { return free_list_.available(); }
|
||||
|
||||
// The limit of allocation for a page in this space.
|
||||
virtual Address PageAllocationLimit(Page* page) {
|
||||
@ -2165,11 +2169,11 @@ class LargeObjectSpace : public Space {
|
||||
Object* AllocateRawFixedArray(int size_in_bytes);
|
||||
|
||||
// Available bytes for objects in this space.
|
||||
int Available() {
|
||||
intptr_t Available() {
|
||||
return LargeObjectChunk::ObjectSizeFor(MemoryAllocator::Available());
|
||||
}
|
||||
|
||||
virtual int Size() {
|
||||
virtual intptr_t Size() {
|
||||
return size_;
|
||||
}
|
||||
|
||||
@ -2223,7 +2227,7 @@ class LargeObjectSpace : public Space {
|
||||
private:
|
||||
// The head of the linked list of large object chunks.
|
||||
LargeObjectChunk* first_chunk_;
|
||||
int size_; // allocated bytes
|
||||
intptr_t size_; // allocated bytes
|
||||
int page_count_; // number of chunks
|
||||
|
||||
|
||||
|
||||
@ -25,7 +25,7 @@
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
// Flags: --max-new-space-size=262144
|
||||
// Flags: --max-new-space-size=256
|
||||
|
||||
function zero() {
|
||||
var x = 0.5;
|
||||
|
||||
@ -25,7 +25,7 @@
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
// Flags: --max-new-space-size=262144
|
||||
// Flags: --max-new-space-size=256
|
||||
|
||||
function zero() {
|
||||
var x = 0.5;
|
||||
|
||||
Loading…
Reference in New Issue
Block a user