HeapStatistics();
size_t total_heap_size() { return total_heap_size_; }
size_t total_heap_size_executable() { return total_heap_size_executable_; }
+ size_t total_physical_size() { return total_physical_size_; }
size_t used_heap_size() { return used_heap_size_; }
size_t heap_size_limit() { return heap_size_limit_; }
void set_total_heap_size_executable(size_t size) {
total_heap_size_executable_ = size;
}
+ void set_total_physical_size(size_t size) {
+ total_physical_size_ = size;
+ }
void set_used_heap_size(size_t size) { used_heap_size_ = size; }
void set_heap_size_limit(size_t size) { heap_size_limit_ = size; }
size_t total_heap_size_;
size_t total_heap_size_executable_;
+ size_t total_physical_size_;
size_t used_heap_size_;
size_t heap_size_limit_;
HeapStatistics::HeapStatistics(): total_heap_size_(0),
total_heap_size_executable_(0),
+ total_physical_size_(0),
used_heap_size_(0),
heap_size_limit_(0) { }
// Isolate is unitialized thus heap is not configured yet.
heap_statistics->set_total_heap_size(0);
heap_statistics->set_total_heap_size_executable(0);
+ heap_statistics->set_total_physical_size(0);
heap_statistics->set_used_heap_size(0);
heap_statistics->set_heap_size_limit(0);
return;
heap_statistics->set_total_heap_size(heap->CommittedMemory());
heap_statistics->set_total_heap_size_executable(
heap->CommittedMemoryExecutable());
+ heap_statistics->set_total_physical_size(heap->CommittedPhysicalMemory());
heap_statistics->set_used_heap_size(heap->SizeOfObjects());
heap_statistics->set_heap_size_limit(heap->MaxReserved());
}
lo_space_->Size();
}
+
+size_t Heap::CommittedPhysicalMemory() {
+ if (!HasBeenSetUp()) return 0;
+
+ return new_space_.CommittedPhysicalMemory() +
+ old_pointer_space_->CommittedPhysicalMemory() +
+ old_data_space_->CommittedPhysicalMemory() +
+ code_space_->CommittedPhysicalMemory() +
+ map_space_->CommittedPhysicalMemory() +
+ cell_space_->CommittedPhysicalMemory() +
+ lo_space_->CommittedPhysicalMemory();
+}
+
+
intptr_t Heap::CommittedMemoryExecutable() {
if (!HasBeenSetUp()) return 0;
// Returns the amount of executable memory currently committed for the heap.
intptr_t CommittedMemoryExecutable();
+ // Returns the amount of phyical memory currently committed for the heap.
+ size_t CommittedPhysicalMemory();
+
// Returns the available bytes in space w/o growing.
// Heap doesn't guarantee that it can allocate an object that requires
// all available bytes. Check MaxHeapObjectSize() instead.
}
+bool VirtualMemory::CommittedPhysicalSizeInRegion(
+ void* base, size_t size, size_t* physical) {
+ // TODO(alph): implement for the platform.
+ return false;
+}
+
+
class Thread::PlatformData : public Malloced {
public:
PlatformData() : thread_(kNoThread) {}
}
+bool VirtualMemory::CommittedPhysicalSizeInRegion(
+ void* base, size_t size, size_t* physical) {
+ // TODO(alph): implement for the platform.
+ return false;
+}
+
+
class Thread::PlatformData : public Malloced {
public:
pthread_t thread_; // Thread handle for pthread.
}
+bool VirtualMemory::CommittedPhysicalSizeInRegion(
+ void* base, size_t size, size_t* physical) {
+ const size_t page_size = sysconf(_SC_PAGESIZE);
+ base = reinterpret_cast<void*>(
+ reinterpret_cast<intptr_t>(base) & ~(page_size - 1));
+ const size_t pages = (size + page_size - 1) / page_size;
+ ScopedVector<unsigned char> buffer(pages);
+ int result = mincore(base, size, buffer.start());
+ if (result) return false;
+ int resident_pages = 0;
+ for (unsigned i = 0; i < pages; ++i) {
+ resident_pages += buffer[i] & 1;
+ }
+ *physical = resident_pages * page_size;
+ return true;
+}
+
+
class Thread::PlatformData : public Malloced {
public:
PlatformData() : thread_(kNoThread) {}
}
+bool VirtualMemory::CommittedPhysicalSizeInRegion(
+ void* base, size_t size, size_t* physical) {
+ // TODO(alph): implement for the platform.
+ return false;
+}
+
+
class Thread::PlatformData : public Malloced {
public:
PlatformData() : thread_(kNoThread) {}
}
+bool VirtualMemory::CommittedPhysicalSizeInRegion(
+ void* base, size_t size, size_t* physical) {
+ // TODO(alph): implement for the platform.
+ return false;
+}
+
+
class Thread::PlatformData : public Malloced {
public:
PlatformData() {
}
+bool VirtualMemory::CommittedPhysicalSizeInRegion(
+ void* base, size_t size, size_t* physical) {
+ // TODO(alph): implement for the platform.
+ return false;
+}
+
+
class Thread::PlatformData : public Malloced {
public:
PlatformData() : thread_(kNoThread) {}
}
+bool VirtualMemory::CommittedPhysicalSizeInRegion(
+ void* base, size_t size, size_t* physical) {
+ // TODO(alph): implement for the platform.
+ return false;
+}
+
+
class Thread::PlatformData : public Malloced {
public:
PlatformData() : thread_(kNoThread) { }
}
+bool VirtualMemory::CommittedPhysicalSizeInRegion(
+ void* base, size_t size, size_t* physical) {
+ // TODO(alph): implement for the platform.
+ return false;
+}
+
+
// ----------------------------------------------------------------------------
// Win32 thread support.
// and the same size it was reserved with.
static bool ReleaseRegion(void* base, size_t size);
+ // Returns the size of committed memory which is currently resident
+ // in the physical memory for the region specified with base and size
+ // arguments.
+ // On success stores the committed physical memory size at the location
+ // pointed by the last argument and returns true. Returns false on failure.
+ static bool CommittedPhysicalSizeInRegion(
+ void* base, size_t size, size_t* physical);
+
private:
void* address_; // Start address of the virtual memory.
size_t size_; // Size of the virtual memory.
}
+size_t MemoryChunk::CommittedPhysicalMemory() {
+ size_t physical;
+ size_t size = area_size();
+ if (VirtualMemory::CommittedPhysicalSizeInRegion(
+ area_start_, size, &physical)) {
+ return physical;
+ } else {
+ return size;
+ }
+}
+
+
MemoryChunk* MemoryAllocator::AllocateChunk(intptr_t body_size,
Executability executable,
Space* owner) {
}
+size_t PagedSpace::CommittedPhysicalMemory() {
+ size_t size = 0;
+ PageIterator it(this);
+ while (it.has_next()) {
+ size += it.next()->CommittedPhysicalMemory();
+ }
+ return size;
+}
+
+
MaybeObject* PagedSpace::FindObject(Address addr) {
// Note: this function can only be called on precisely swept spaces.
ASSERT(!heap()->mark_compact_collector()->in_use());
}
+size_t SemiSpace::CommittedPhysicalMemory() {
+ if (!is_committed()) return 0;
+ size_t size = 0;
+ NewSpacePageIterator it(this);
+ while (it.has_next()) {
+ size += it.next()->CommittedPhysicalMemory();
+ }
+ return size;
+}
+
+
bool SemiSpace::GrowTo(int new_capacity) {
if (!is_committed()) {
if (!Commit()) return false;
}
+size_t LargeObjectSpace::CommittedPhysicalMemory() {
+ size_t size = 0;
+ LargePage* current = first_page_;
+ while (current != NULL) {
+ size += current->CommittedPhysicalMemory();
+ current = current->next_page();
+ }
+ return size;
+}
+
+
// GC support
MaybeObject* LargeObjectSpace::FindObject(Address a) {
LargePage* page = FindPage(a);
return static_cast<int>(area_end() - area_start());
}
+ size_t CommittedPhysicalMemory();
+
protected:
MemoryChunk* next_chunk_;
MemoryChunk* prev_chunk_;
// spaces this equals the capacity.
intptr_t CommittedMemory() { return Capacity(); }
+ // Total amount of physical memory committed for this space.
+ size_t CommittedPhysicalMemory();
+
// Sets the capacity, the available space and the wasted space to zero.
// The stats are rebuilt during sweeping by adding each page to the
// capacity and the size when it is encountered. As free spaces are
static void Swap(SemiSpace* from, SemiSpace* to);
+ size_t CommittedPhysicalMemory();
+
private:
// Flips the semispace between being from-space and to-space.
// Copies the flags into the masked positions on all pages in the space.
return Capacity();
}
+ size_t CommittedPhysicalMemory() {
+ return to_space_.CommittedPhysicalMemory()
+ + (from_space_.is_committed() ? from_space_.CommittedPhysicalMemory()
+ : 0);
+ }
+
// Return the available bytes without growing.
intptr_t Available() {
return Capacity() - Size();
return Size();
}
+ size_t CommittedPhysicalMemory();
+
int PageCount() {
return page_count_;
}
projects / platform / upstream / v8.git / commitdiff