From f1635606df5b485ace4fdae3582241787a1cef9c Mon Sep 17 00:00:00 2001 From: "erik.corry@gmail.com" Date: Tue, 28 Sep 2010 10:35:47 +0000 Subject: [PATCH] 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 --- src/flag-definitions.h | 4 +-- src/heap.cc | 86 ++++++++++++++++++++++++++++------------------ src/heap.h | 28 +++++++-------- src/spaces.cc | 27 +++++++++------ src/spaces.h | 78 +++++++++++++++++++++-------------------- test/mjsunit/math-abs.js | 2 +- test/mjsunit/math-floor.js | 2 +- 7 files changed, 129 insertions(+), 98 deletions(-) diff --git a/src/flag-definitions.h b/src/flag-definitions.h index 263a2a4..165af3f 100644 --- a/src/flag-definitions.h +++ b/src/flag-definitions.h @@ -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 allocations") DEFINE_bool(trace_gc, false, diff --git a/src/heap.cc b/src/heap.cc index 047e331..26d0087 100644 --- a/src/heap.cc +++ b/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(p), + reinterpret_cast(*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(scopes_[Scope::MC_SWEEP_NEWSPACE])); PrintF("compact=%d ", static_cast(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"); } diff --git a/src/heap.h b/src/heap.h index 8a11530..c90f880 100644 --- a/src/heap.h +++ b/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_; }; diff --git a/src/spaces.cc b/src/spaces.cc index 3d2d42f..ebc5ec7 100644 --- a/src/spaces.cc +++ b/src/spaces.cc @@ -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::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(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(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(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(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); diff --git a/src/spaces.h b/src/spaces.h index 94e0cd2..8557e15 100644 --- a/src/spaces.h +++ b/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(top() - bottom()); } + virtual intptr_t Size() { return static_cast(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 diff --git a/test/mjsunit/math-abs.js b/test/mjsunit/math-abs.js index a40243b..bec1a01 100644 --- a/test/mjsunit/math-abs.js +++ b/test/mjsunit/math-abs.js @@ -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; diff --git a/test/mjsunit/math-floor.js b/test/mjsunit/math-floor.js index e56341c..0d1c0ac 100644 --- a/test/mjsunit/math-floor.js +++ b/test/mjsunit/math-floor.js @@ -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; -- 2.7.4