| // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| // --- |
| // Author: Sainbayar Sukhbaatar |
| // Dai Mikurube |
| // |
| |
| #include "deep-heap-profile.h" |
| |
| #ifdef USE_DEEP_HEAP_PROFILE |
| #include <algorithm> |
| #include <fcntl.h> |
| #include <sys/stat.h> |
| #include <sys/types.h> |
| #include <time.h> |
| #ifdef HAVE_UNISTD_H |
| #include <unistd.h> // for getpagesize and getpid |
| #endif // HAVE_UNISTD_H |
| |
| #if defined(__linux__) |
| #include <endian.h> |
| #if !defined(__LITTLE_ENDIAN__) and !defined(__BIG_ENDIAN__) |
| #if __BYTE_ORDER == __BIG_ENDIAN |
| #define __BIG_ENDIAN__ |
| #endif // __BYTE_ORDER == __BIG_ENDIAN |
| #endif // !defined(__LITTLE_ENDIAN__) and !defined(__BIG_ENDIAN__) |
| #if defined(__BIG_ENDIAN__) |
| #include <byteswap.h> |
| #endif // defined(__BIG_ENDIAN__) |
| #endif // defined(__linux__) |
| #if defined(COMPILER_MSVC) |
| #include <Winsock2.h> // for gethostname |
| #endif // defined(COMPILER_MSVC) |
| |
| #include "base/cycleclock.h" |
| #include "base/sysinfo.h" |
| #include "internal_logging.h" // for ASSERT, etc |
| |
| static const int kProfilerBufferSize = 1 << 20; |
| static const int kHashTableSize = 179999; // Same as heap-profile-table.cc. |
| |
| static const int PAGEMAP_BYTES = 8; |
| static const int KPAGECOUNT_BYTES = 8; |
| static const uint64 MAX_ADDRESS = kuint64max; |
| |
| // Tag strings in heap profile dumps. |
| static const char kProfileHeader[] = "heap profile: "; |
| static const char kProfileVersion[] = "DUMP_DEEP_6"; |
| static const char kMetaInformationHeader[] = "META:\n"; |
| static const char kMMapListHeader[] = "MMAP_LIST:\n"; |
| static const char kGlobalStatsHeader[] = "GLOBAL_STATS:\n"; |
| static const char kStacktraceHeader[] = "STACKTRACES:\n"; |
| static const char kProcSelfMapsHeader[] = "\nMAPPED_LIBRARIES:\n"; |
| |
| static const char kVirtualLabel[] = "virtual"; |
| static const char kCommittedLabel[] = "committed"; |
| |
| #if defined(__linux__) |
| #define OS_NAME "linux" |
| #elif defined(_WIN32) || defined(_WIN64) |
| #define OS_NAME "windows" |
| #else |
| #define OS_NAME "unknown-os" |
| #endif |
| |
| bool DeepHeapProfile::AppendCommandLine(TextBuffer* buffer) { |
| #if defined(__linux__) |
| RawFD fd; |
| char filename[100]; |
| char cmdline[4096]; |
| snprintf(filename, sizeof(filename), "/proc/%d/cmdline", |
| static_cast<int>(getpid())); |
| fd = open(filename, O_RDONLY); |
| if (fd == kIllegalRawFD) { |
| RAW_VLOG(0, "Failed to open /proc/self/cmdline"); |
| return false; |
| } |
| |
| size_t length = read(fd, cmdline, sizeof(cmdline) - 1); |
| close(fd); |
| |
| for (int i = 0; i < length; ++i) |
| if (cmdline[i] == '\0') |
| cmdline[i] = ' '; |
| cmdline[length] = '\0'; |
| |
| buffer->AppendString("CommandLine: ", 0); |
| buffer->AppendString(cmdline, 0); |
| buffer->AppendChar('\n'); |
| |
| return true; |
| #else |
| return false; |
| #endif |
| } |
| |
| #if defined(_WIN32) || defined(_WIN64) |
| |
| // TODO(peria): Implement this function. |
| void DeepHeapProfile::MemoryInfoGetterWindows::Initialize() { |
| } |
| |
| // TODO(peria): Implement this function. |
| size_t DeepHeapProfile::MemoryInfoGetterWindows::CommittedSize( |
| uint64 first_address, |
| uint64 last_address, |
| TextBuffer* buffer) const { |
| return 0; |
| } |
| |
| // TODO(peria): Implement this function. |
| bool DeepHeapProfile::MemoryInfoGetterWindows::IsPageCountAvailable() const { |
| return false; |
| } |
| |
| #endif // defined(_WIN32) || defined(_WIN64) |
| |
| #if defined(__linux__) |
| |
| void DeepHeapProfile::MemoryInfoGetterLinux::Initialize() { |
| char filename[100]; |
| snprintf(filename, sizeof(filename), "/proc/%d/pagemap", |
| static_cast<int>(getpid())); |
| pagemap_fd_ = open(filename, O_RDONLY); |
| RAW_CHECK(pagemap_fd_ != -1, "Failed to open /proc/self/pagemap"); |
| |
| if (pageframe_type_ == DUMP_PAGECOUNT) { |
| snprintf(filename, sizeof(filename), "/proc/kpagecount"); |
| kpagecount_fd_ = open(filename, O_RDONLY); |
| if (kpagecount_fd_ == -1) |
| RAW_VLOG(0, "Failed to open /proc/kpagecount"); |
| } |
| } |
| |
| size_t DeepHeapProfile::MemoryInfoGetterLinux::CommittedSize( |
| uint64 first_address, |
| uint64 last_address, |
| DeepHeapProfile::TextBuffer* buffer) const { |
| int page_size = getpagesize(); |
| uint64 page_address = (first_address / page_size) * page_size; |
| size_t committed_size = 0; |
| size_t pageframe_list_length = 0; |
| |
| Seek(first_address); |
| |
| // Check every page on which the allocation resides. |
| while (page_address <= last_address) { |
| // Read corresponding physical page. |
| State state; |
| // TODO(dmikurube): Read pagemap in bulk for speed. |
| // TODO(dmikurube): Consider using mincore(2). |
| if (Read(&state, pageframe_type_ != DUMP_NO_PAGEFRAME) == false) { |
| // We can't read the last region (e.g vsyscall). |
| #ifndef NDEBUG |
| RAW_VLOG(0, "pagemap read failed @ %#llx %" PRId64 " bytes", |
| first_address, last_address - first_address + 1); |
| #endif |
| return 0; |
| } |
| |
| // Dump pageframes of resident pages. Non-resident pages are just skipped. |
| if (pageframe_type_ != DUMP_NO_PAGEFRAME && |
| buffer != NULL && state.pfn != 0) { |
| if (pageframe_list_length == 0) { |
| buffer->AppendString(" PF:", 0); |
| pageframe_list_length = 5; |
| } |
| buffer->AppendChar(' '); |
| if (page_address < first_address) |
| buffer->AppendChar('<'); |
| buffer->AppendBase64(state.pfn, 4); |
| pageframe_list_length += 5; |
| if (pageframe_type_ == DUMP_PAGECOUNT && IsPageCountAvailable()) { |
| uint64 pagecount = ReadPageCount(state.pfn); |
| // Assume pagecount == 63 if the pageframe is mapped more than 63 times. |
| if (pagecount > 63) |
| pagecount = 63; |
| buffer->AppendChar('#'); |
| buffer->AppendBase64(pagecount, 1); |
| pageframe_list_length += 2; |
| } |
| if (last_address < page_address - 1 + page_size) |
| buffer->AppendChar('>'); |
| // Begins a new line every 94 characters. |
| if (pageframe_list_length > 94) { |
| buffer->AppendChar('\n'); |
| pageframe_list_length = 0; |
| } |
| } |
| |
| if (state.is_committed) { |
| // Calculate the size of the allocation part in this page. |
| size_t bytes = page_size; |
| |
| // If looking at the last page in a given region. |
| if (last_address <= page_address - 1 + page_size) { |
| bytes = last_address - page_address + 1; |
| } |
| |
| // If looking at the first page in a given region. |
| if (page_address < first_address) { |
| bytes -= first_address - page_address; |
| } |
| |
| committed_size += bytes; |
| } |
| if (page_address > MAX_ADDRESS - page_size) { |
| break; |
| } |
| page_address += page_size; |
| } |
| |
| if (pageframe_type_ != DUMP_NO_PAGEFRAME && |
| buffer != NULL && pageframe_list_length != 0) { |
| buffer->AppendChar('\n'); |
| } |
| |
| return committed_size; |
| } |
| |
| uint64 DeepHeapProfile::MemoryInfoGetterLinux::ReadPageCount(uint64 pfn) const { |
| int64 index = pfn * KPAGECOUNT_BYTES; |
| int64 offset = lseek64(kpagecount_fd_, index, SEEK_SET); |
| RAW_DCHECK(offset == index, "Failed in seeking in kpagecount."); |
| |
| uint64 kpagecount_value; |
| int result = read(kpagecount_fd_, &kpagecount_value, KPAGECOUNT_BYTES); |
| if (result != KPAGECOUNT_BYTES) |
| return 0; |
| |
| return kpagecount_value; |
| } |
| |
| bool DeepHeapProfile::MemoryInfoGetterLinux::Seek(uint64 address) const { |
| int64 index = (address / getpagesize()) * PAGEMAP_BYTES; |
| RAW_DCHECK(pagemap_fd_ != -1, "Failed to seek in /proc/self/pagemap"); |
| int64 offset = lseek64(pagemap_fd_, index, SEEK_SET); |
| RAW_DCHECK(offset == index, "Failed in seeking."); |
| return offset >= 0; |
| } |
| |
| bool DeepHeapProfile::MemoryInfoGetterLinux::Read( |
| State* state, bool get_pfn) const { |
| static const uint64 U64_1 = 1; |
| static const uint64 PFN_FILTER = (U64_1 << 55) - U64_1; |
| static const uint64 PAGE_PRESENT = U64_1 << 63; |
| static const uint64 PAGE_SWAP = U64_1 << 62; |
| static const uint64 PAGE_RESERVED = U64_1 << 61; |
| static const uint64 FLAG_NOPAGE = U64_1 << 20; |
| static const uint64 FLAG_KSM = U64_1 << 21; |
| static const uint64 FLAG_MMAP = U64_1 << 11; |
| |
| uint64 pagemap_value; |
| RAW_DCHECK(pagemap_fd_ != -1, "Failed to read from /proc/self/pagemap"); |
| int result = read(pagemap_fd_, &pagemap_value, PAGEMAP_BYTES); |
| if (result != PAGEMAP_BYTES) { |
| return false; |
| } |
| |
| // Check if the page is committed. |
| state->is_committed = (pagemap_value & (PAGE_PRESENT | PAGE_SWAP)); |
| |
| state->is_present = (pagemap_value & PAGE_PRESENT); |
| state->is_swapped = (pagemap_value & PAGE_SWAP); |
| state->is_shared = false; |
| |
| if (get_pfn && state->is_present && !state->is_swapped) |
| state->pfn = (pagemap_value & PFN_FILTER); |
| else |
| state->pfn = 0; |
| |
| return true; |
| } |
| |
| bool DeepHeapProfile::MemoryInfoGetterLinux::IsPageCountAvailable() const { |
| return kpagecount_fd_ != -1; |
| } |
| |
| #endif // defined(__linux__) |
| |
| DeepHeapProfile::MemoryResidenceInfoGetterInterface:: |
| MemoryResidenceInfoGetterInterface() {} |
| |
| DeepHeapProfile::MemoryResidenceInfoGetterInterface:: |
| ~MemoryResidenceInfoGetterInterface() {} |
| |
| DeepHeapProfile::MemoryResidenceInfoGetterInterface* |
| DeepHeapProfile::MemoryResidenceInfoGetterInterface::Create( |
| PageFrameType pageframe_type) { |
| #if defined(_WIN32) || defined(_WIN64) |
| return new MemoryInfoGetterWindows(pageframe_type); |
| #elif defined(__linux__) |
| return new MemoryInfoGetterLinux(pageframe_type); |
| #else |
| return NULL; |
| #endif |
| } |
| |
| DeepHeapProfile::DeepHeapProfile(HeapProfileTable* heap_profile, |
| const char* prefix, |
| enum PageFrameType pageframe_type) |
| : memory_residence_info_getter_( |
| MemoryResidenceInfoGetterInterface::Create(pageframe_type)), |
| most_recent_pid_(-1), |
| stats_(), |
| dump_count_(0), |
| filename_prefix_(NULL), |
| deep_table_(kHashTableSize, heap_profile->alloc_, heap_profile->dealloc_), |
| pageframe_type_(pageframe_type), |
| heap_profile_(heap_profile) { |
| // Copy filename prefix. |
| const int prefix_length = strlen(prefix); |
| filename_prefix_ = |
| reinterpret_cast<char*>(heap_profile_->alloc_(prefix_length + 1)); |
| memcpy(filename_prefix_, prefix, prefix_length); |
| filename_prefix_[prefix_length] = '\0'; |
| |
| strncpy(run_id_, "undetermined-run-id", sizeof(run_id_)); |
| } |
| |
| DeepHeapProfile::~DeepHeapProfile() { |
| heap_profile_->dealloc_(filename_prefix_); |
| delete memory_residence_info_getter_; |
| } |
| |
| // Global malloc() should not be used in this function. |
| // Use LowLevelAlloc if required. |
| void DeepHeapProfile::DumpOrderedProfile(const char* reason, |
| char raw_buffer[], |
| int buffer_size, |
| RawFD fd) { |
| TextBuffer buffer(raw_buffer, buffer_size, fd); |
| |
| #ifndef NDEBUG |
| int64 starting_cycles = CycleClock::Now(); |
| #endif |
| |
| // Get the time before starting snapshot. |
| // TODO(dmikurube): Consider gettimeofday if available. |
| time_t time_value = time(NULL); |
| |
| ++dump_count_; |
| |
| // Re-open files in /proc/pid/ if the process is newly forked one. |
| if (most_recent_pid_ != getpid()) { |
| char hostname[64]; |
| if (0 == gethostname(hostname, sizeof(hostname))) { |
| char* dot = strchr(hostname, '.'); |
| if (dot != NULL) |
| *dot = '\0'; |
| } else { |
| strcpy(hostname, "unknown"); |
| } |
| |
| most_recent_pid_ = getpid(); |
| |
| snprintf(run_id_, sizeof(run_id_), "%s-" OS_NAME "-%d-%lu", |
| hostname, most_recent_pid_, time(NULL)); |
| |
| if (memory_residence_info_getter_) |
| memory_residence_info_getter_->Initialize(); |
| deep_table_.ResetIsLogged(); |
| |
| // Write maps into "|filename_prefix_|.<pid>.maps". |
| WriteProcMaps(filename_prefix_, raw_buffer, buffer_size); |
| } |
| |
| // Reset committed sizes of buckets. |
| deep_table_.ResetCommittedSize(); |
| |
| // Record committed sizes. |
| stats_.SnapshotAllocations(this); |
| |
| // TODO(dmikurube): Eliminate dynamic memory allocation caused by snprintf. |
| // glibc's snprintf internally allocates memory by alloca normally, but it |
| // allocates memory by malloc if large memory is required. |
| |
| buffer.AppendString(kProfileHeader, 0); |
| buffer.AppendString(kProfileVersion, 0); |
| buffer.AppendString("\n", 0); |
| |
| // Fill buffer with meta information. |
| buffer.AppendString(kMetaInformationHeader, 0); |
| |
| buffer.AppendString("Time: ", 0); |
| buffer.AppendUnsignedLong(time_value, 0); |
| buffer.AppendChar('\n'); |
| |
| if (reason != NULL) { |
| buffer.AppendString("Reason: ", 0); |
| buffer.AppendString(reason, 0); |
| buffer.AppendChar('\n'); |
| } |
| |
| AppendCommandLine(&buffer); |
| |
| buffer.AppendString("RunID: ", 0); |
| buffer.AppendString(run_id_, 0); |
| buffer.AppendChar('\n'); |
| |
| buffer.AppendString("PageSize: ", 0); |
| buffer.AppendInt(getpagesize(), 0, 0); |
| buffer.AppendChar('\n'); |
| |
| // Assumes the physical memory <= 64GB (PFN < 2^24). |
| if (pageframe_type_ == DUMP_PAGECOUNT && memory_residence_info_getter_ && |
| memory_residence_info_getter_->IsPageCountAvailable()) { |
| buffer.AppendString("PageFrame: 24,Base64,PageCount", 0); |
| buffer.AppendChar('\n'); |
| } else if (pageframe_type_ != DUMP_NO_PAGEFRAME) { |
| buffer.AppendString("PageFrame: 24,Base64", 0); |
| buffer.AppendChar('\n'); |
| } |
| |
| // Fill buffer with the global stats. |
| buffer.AppendString(kMMapListHeader, 0); |
| |
| stats_.SnapshotMaps(memory_residence_info_getter_, this, &buffer); |
| |
| // Fill buffer with the global stats. |
| buffer.AppendString(kGlobalStatsHeader, 0); |
| |
| stats_.Unparse(&buffer); |
| |
| buffer.AppendString(kStacktraceHeader, 0); |
| buffer.AppendString(kVirtualLabel, 10); |
| buffer.AppendChar(' '); |
| buffer.AppendString(kCommittedLabel, 10); |
| buffer.AppendString("\n", 0); |
| |
| // Fill buffer. |
| deep_table_.UnparseForStats(&buffer); |
| |
| buffer.Flush(); |
| |
| // Write the bucket listing into a .bucket file. |
| deep_table_.WriteForBucketFile( |
| filename_prefix_, dump_count_, raw_buffer, buffer_size); |
| |
| #ifndef NDEBUG |
| int64 elapsed_cycles = CycleClock::Now() - starting_cycles; |
| double elapsed_seconds = elapsed_cycles / CyclesPerSecond(); |
| RAW_VLOG(0, "Time spent on DeepProfiler: %.3f sec\n", elapsed_seconds); |
| #endif |
| } |
| |
| int DeepHeapProfile::TextBuffer::Size() { |
| return size_; |
| } |
| |
| int DeepHeapProfile::TextBuffer::FilledBytes() { |
| return cursor_; |
| } |
| |
| void DeepHeapProfile::TextBuffer::Clear() { |
| cursor_ = 0; |
| } |
| |
| void DeepHeapProfile::TextBuffer::Flush() { |
| RawWrite(fd_, buffer_, cursor_); |
| cursor_ = 0; |
| } |
| |
| // TODO(dmikurube): These Append* functions should not use snprintf. |
| bool DeepHeapProfile::TextBuffer::AppendChar(char value) { |
| return ForwardCursor(snprintf(buffer_ + cursor_, size_ - cursor_, |
| "%c", value)); |
| } |
| |
| bool DeepHeapProfile::TextBuffer::AppendString(const char* value, int width) { |
| char* position = buffer_ + cursor_; |
| int available = size_ - cursor_; |
| int appended; |
| if (width == 0) |
| appended = snprintf(position, available, "%s", value); |
| else |
| appended = snprintf(position, available, "%*s", |
| width, value); |
| return ForwardCursor(appended); |
| } |
| |
| bool DeepHeapProfile::TextBuffer::AppendInt(int value, int width, |
| bool leading_zero) { |
| char* position = buffer_ + cursor_; |
| int available = size_ - cursor_; |
| int appended; |
| if (width == 0) |
| appended = snprintf(position, available, "%d", value); |
| else if (leading_zero) |
| appended = snprintf(position, available, "%0*d", width, value); |
| else |
| appended = snprintf(position, available, "%*d", width, value); |
| return ForwardCursor(appended); |
| } |
| |
| bool DeepHeapProfile::TextBuffer::AppendLong(long value, int width) { |
| char* position = buffer_ + cursor_; |
| int available = size_ - cursor_; |
| int appended; |
| if (width == 0) |
| appended = snprintf(position, available, "%ld", value); |
| else |
| appended = snprintf(position, available, "%*ld", width, value); |
| return ForwardCursor(appended); |
| } |
| |
| bool DeepHeapProfile::TextBuffer::AppendUnsignedLong(unsigned long value, |
| int width) { |
| char* position = buffer_ + cursor_; |
| int available = size_ - cursor_; |
| int appended; |
| if (width == 0) |
| appended = snprintf(position, available, "%lu", value); |
| else |
| appended = snprintf(position, available, "%*lu", width, value); |
| return ForwardCursor(appended); |
| } |
| |
| bool DeepHeapProfile::TextBuffer::AppendInt64(int64 value, int width) { |
| char* position = buffer_ + cursor_; |
| int available = size_ - cursor_; |
| int appended; |
| if (width == 0) |
| appended = snprintf(position, available, "%" PRId64, value); |
| else |
| appended = snprintf(position, available, "%*" PRId64, width, value); |
| return ForwardCursor(appended); |
| } |
| |
| bool DeepHeapProfile::TextBuffer::AppendPtr(uint64 value, int width) { |
| char* position = buffer_ + cursor_; |
| int available = size_ - cursor_; |
| int appended; |
| if (width == 0) |
| appended = snprintf(position, available, "%" PRIx64, value); |
| else |
| appended = snprintf(position, available, "%0*" PRIx64, width, value); |
| return ForwardCursor(appended); |
| } |
| |
| bool DeepHeapProfile::TextBuffer::AppendBase64(uint64 value, int width) { |
| static const char base64[65] = |
| "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; |
| #if defined(__BIG_ENDIAN__) |
| value = bswap_64(value); |
| #endif |
| for (int shift = (width - 1) * 6; shift >= 0; shift -= 6) { |
| if (!AppendChar(base64[(value >> shift) & 0x3f])) |
| return false; |
| } |
| return true; |
| } |
| |
| bool DeepHeapProfile::TextBuffer::ForwardCursor(int appended) { |
| if (appended < 0 || appended >= size_ - cursor_) |
| return false; |
| cursor_ += appended; |
| if (cursor_ > size_ * 4 / 5) |
| Flush(); |
| return true; |
| } |
| |
| void DeepHeapProfile::DeepBucket::UnparseForStats(TextBuffer* buffer) { |
| buffer->AppendInt64(bucket->alloc_size - bucket->free_size, 10); |
| buffer->AppendChar(' '); |
| buffer->AppendInt64(committed_size, 10); |
| buffer->AppendChar(' '); |
| buffer->AppendInt(bucket->allocs, 6, false); |
| buffer->AppendChar(' '); |
| buffer->AppendInt(bucket->frees, 6, false); |
| buffer->AppendString(" @ ", 0); |
| buffer->AppendInt(id, 0, false); |
| buffer->AppendString("\n", 0); |
| } |
| |
| void DeepHeapProfile::DeepBucket::UnparseForBucketFile(TextBuffer* buffer) { |
| buffer->AppendInt(id, 0, false); |
| buffer->AppendChar(' '); |
| buffer->AppendString(is_mmap ? "mmap" : "malloc", 0); |
| |
| #if defined(TYPE_PROFILING) |
| buffer->AppendString(" t0x", 0); |
| buffer->AppendPtr(reinterpret_cast<uintptr_t>(type), 0); |
| if (type == NULL) { |
| buffer->AppendString(" nno_typeinfo", 0); |
| } else { |
| buffer->AppendString(" n", 0); |
| buffer->AppendString(type->name(), 0); |
| } |
| #endif |
| |
| for (int depth = 0; depth < bucket->depth; depth++) { |
| buffer->AppendString(" 0x", 0); |
| buffer->AppendPtr(reinterpret_cast<uintptr_t>(bucket->stack[depth]), 8); |
| } |
| buffer->AppendString("\n", 0); |
| } |
| |
| DeepHeapProfile::DeepBucketTable::DeepBucketTable( |
| int table_size, |
| HeapProfileTable::Allocator alloc, |
| HeapProfileTable::DeAllocator dealloc) |
| : table_(NULL), |
| table_size_(table_size), |
| alloc_(alloc), |
| dealloc_(dealloc), |
| bucket_id_(0) { |
| const int bytes = table_size * sizeof(DeepBucket*); |
| table_ = reinterpret_cast<DeepBucket**>(alloc(bytes)); |
| memset(table_, 0, bytes); |
| } |
| |
| DeepHeapProfile::DeepBucketTable::~DeepBucketTable() { |
| ASSERT(table_ != NULL); |
| for (int db = 0; db < table_size_; db++) { |
| for (DeepBucket* x = table_[db]; x != 0; /**/) { |
| DeepBucket* db = x; |
| x = x->next; |
| dealloc_(db); |
| } |
| } |
| dealloc_(table_); |
| } |
| |
| DeepHeapProfile::DeepBucket* DeepHeapProfile::DeepBucketTable::Lookup( |
| Bucket* bucket, |
| #if defined(TYPE_PROFILING) |
| const std::type_info* type, |
| #endif |
| bool is_mmap) { |
| // Make hash-value |
| uintptr_t h = 0; |
| |
| AddToHashValue(reinterpret_cast<uintptr_t>(bucket), &h); |
| if (is_mmap) { |
| AddToHashValue(1, &h); |
| } else { |
| AddToHashValue(0, &h); |
| } |
| |
| #if defined(TYPE_PROFILING) |
| if (type == NULL) { |
| AddToHashValue(0, &h); |
| } else { |
| AddToHashValue(reinterpret_cast<uintptr_t>(type->name()), &h); |
| } |
| #endif |
| |
| FinishHashValue(&h); |
| |
| // Lookup stack trace in table |
| unsigned int buck = ((unsigned int) h) % table_size_; |
| for (DeepBucket* db = table_[buck]; db != 0; db = db->next) { |
| if (db->bucket == bucket) { |
| return db; |
| } |
| } |
| |
| // Create a new bucket |
| DeepBucket* db = reinterpret_cast<DeepBucket*>(alloc_(sizeof(DeepBucket))); |
| memset(db, 0, sizeof(*db)); |
| db->bucket = bucket; |
| #if defined(TYPE_PROFILING) |
| db->type = type; |
| #endif |
| db->committed_size = 0; |
| db->is_mmap = is_mmap; |
| db->id = (bucket_id_++); |
| db->is_logged = false; |
| db->next = table_[buck]; |
| table_[buck] = db; |
| return db; |
| } |
| |
| // TODO(dmikurube): Eliminate dynamic memory allocation caused by snprintf. |
| void DeepHeapProfile::DeepBucketTable::UnparseForStats(TextBuffer* buffer) { |
| for (int i = 0; i < table_size_; i++) { |
| for (DeepBucket* deep_bucket = table_[i]; |
| deep_bucket != NULL; |
| deep_bucket = deep_bucket->next) { |
| Bucket* bucket = deep_bucket->bucket; |
| if (bucket->alloc_size - bucket->free_size == 0) { |
| continue; // Skip empty buckets. |
| } |
| deep_bucket->UnparseForStats(buffer); |
| } |
| } |
| } |
| |
| void DeepHeapProfile::DeepBucketTable::WriteForBucketFile( |
| const char* prefix, int dump_count, char raw_buffer[], int buffer_size) { |
| char filename[100]; |
| snprintf(filename, sizeof(filename), |
| "%s.%05d.%04d.buckets", prefix, getpid(), dump_count); |
| RawFD fd = RawOpenForWriting(filename); |
| RAW_DCHECK(fd != kIllegalRawFD, ""); |
| |
| TextBuffer buffer(raw_buffer, buffer_size, fd); |
| |
| for (int i = 0; i < table_size_; i++) { |
| for (DeepBucket* deep_bucket = table_[i]; |
| deep_bucket != NULL; |
| deep_bucket = deep_bucket->next) { |
| Bucket* bucket = deep_bucket->bucket; |
| if (deep_bucket->is_logged) { |
| continue; // Skip the bucket if it is already logged. |
| } |
| if (!deep_bucket->is_mmap && |
| bucket->alloc_size - bucket->free_size <= 64) { |
| continue; // Skip small malloc buckets. |
| } |
| |
| deep_bucket->UnparseForBucketFile(&buffer); |
| deep_bucket->is_logged = true; |
| } |
| } |
| |
| buffer.Flush(); |
| RawClose(fd); |
| } |
| |
| void DeepHeapProfile::DeepBucketTable::ResetCommittedSize() { |
| for (int i = 0; i < table_size_; i++) { |
| for (DeepBucket* deep_bucket = table_[i]; |
| deep_bucket != NULL; |
| deep_bucket = deep_bucket->next) { |
| deep_bucket->committed_size = 0; |
| } |
| } |
| } |
| |
| void DeepHeapProfile::DeepBucketTable::ResetIsLogged() { |
| for (int i = 0; i < table_size_; i++) { |
| for (DeepBucket* deep_bucket = table_[i]; |
| deep_bucket != NULL; |
| deep_bucket = deep_bucket->next) { |
| deep_bucket->is_logged = false; |
| } |
| } |
| } |
| |
| // This hash function is from HeapProfileTable::GetBucket. |
| // static |
| void DeepHeapProfile::DeepBucketTable::AddToHashValue( |
| uintptr_t add, uintptr_t* hash_value) { |
| *hash_value += add; |
| *hash_value += *hash_value << 10; |
| *hash_value ^= *hash_value >> 6; |
| } |
| |
| // This hash function is from HeapProfileTable::GetBucket. |
| // static |
| void DeepHeapProfile::DeepBucketTable::FinishHashValue(uintptr_t* hash_value) { |
| *hash_value += *hash_value << 3; |
| *hash_value ^= *hash_value >> 11; |
| } |
| |
| void DeepHeapProfile::RegionStats::Initialize() { |
| virtual_bytes_ = 0; |
| committed_bytes_ = 0; |
| } |
| |
| uint64 DeepHeapProfile::RegionStats::Record( |
| const MemoryResidenceInfoGetterInterface* memory_residence_info_getter, |
| uint64 first_address, |
| uint64 last_address, |
| TextBuffer* buffer) { |
| uint64 committed = 0; |
| virtual_bytes_ += static_cast<size_t>(last_address - first_address + 1); |
| if (memory_residence_info_getter) |
| committed = memory_residence_info_getter->CommittedSize(first_address, |
| last_address, |
| buffer); |
| committed_bytes_ += committed; |
| return committed; |
| } |
| |
| void DeepHeapProfile::RegionStats::Unparse(const char* name, |
| TextBuffer* buffer) { |
| buffer->AppendString(name, 25); |
| buffer->AppendChar(' '); |
| buffer->AppendLong(virtual_bytes_, 12); |
| buffer->AppendChar(' '); |
| buffer->AppendLong(committed_bytes_, 12); |
| buffer->AppendString("\n", 0); |
| } |
| |
| // Snapshots all virtual memory mapping stats by merging mmap(2) records from |
| // MemoryRegionMap and /proc/maps, the OS-level memory mapping information. |
| // Memory regions described in /proc/maps, but which are not created by mmap, |
| // are accounted as "unhooked" memory regions. |
| // |
| // This function assumes that every memory region created by mmap is covered |
| // by VMA(s) described in /proc/maps except for http://crbug.com/189114. |
| // Note that memory regions created with mmap don't align with borders of VMAs |
| // in /proc/maps. In other words, a memory region by mmap can cut across many |
| // VMAs. Also, of course a VMA can include many memory regions by mmap. |
| // It means that the following situation happens: |
| // |
| // => Virtual address |
| // <----- VMA #1 -----><----- VMA #2 ----->...<----- VMA #3 -----><- VMA #4 -> |
| // ..< mmap #1 >.<- mmap #2 -><- mmap #3 ->...<- mmap #4 ->..<-- mmap #5 -->.. |
| // |
| // It can happen easily as permission can be changed by mprotect(2) for a part |
| // of a memory region. A change in permission splits VMA(s). |
| // |
| // To deal with the situation, this function iterates over MemoryRegionMap and |
| // /proc/maps independently. The iterator for MemoryRegionMap is initialized |
| // at the top outside the loop for /proc/maps, and it goes forward inside the |
| // loop while comparing their addresses. |
| // |
| // TODO(dmikurube): Eliminate dynamic memory allocation caused by snprintf. |
| void DeepHeapProfile::GlobalStats::SnapshotMaps( |
| const MemoryResidenceInfoGetterInterface* memory_residence_info_getter, |
| DeepHeapProfile* deep_profile, |
| TextBuffer* mmap_dump_buffer) { |
| MemoryRegionMap::LockHolder lock_holder; |
| ProcMapsIterator::Buffer procmaps_iter_buffer; |
| ProcMapsIterator procmaps_iter(0, &procmaps_iter_buffer); |
| uint64 vma_start_addr, vma_last_addr, offset; |
| int64 inode; |
| char* flags; |
| char* filename; |
| enum MapsRegionType type; |
| |
| for (int i = 0; i < NUMBER_OF_MAPS_REGION_TYPES; ++i) { |
| all_[i].Initialize(); |
| unhooked_[i].Initialize(); |
| } |
| profiled_mmap_.Initialize(); |
| |
| MemoryRegionMap::RegionIterator mmap_iter = |
| MemoryRegionMap::BeginRegionLocked(); |
| DeepBucket* deep_bucket = NULL; |
| if (mmap_iter != MemoryRegionMap::EndRegionLocked()) { |
| deep_bucket = GetInformationOfMemoryRegion( |
| mmap_iter, memory_residence_info_getter, deep_profile); |
| } |
| |
| while (procmaps_iter.Next(&vma_start_addr, &vma_last_addr, |
| &flags, &offset, &inode, &filename)) { |
| if (mmap_dump_buffer) { |
| char buffer[1024]; |
| int written = procmaps_iter.FormatLine(buffer, sizeof(buffer), |
| vma_start_addr, vma_last_addr, |
| flags, offset, inode, filename, 0); |
| mmap_dump_buffer->AppendString(buffer, 0); |
| } |
| |
| // 'vma_last_addr' should be the last inclusive address of the region. |
| vma_last_addr -= 1; |
| if (strcmp("[vsyscall]", filename) == 0) { |
| continue; // Reading pagemap will fail in [vsyscall]. |
| } |
| |
| // TODO(dmikurube): |type| will be deprecated in the dump. |
| // See http://crbug.com/245603. |
| type = ABSENT; |
| if (filename[0] == '/') { |
| if (flags[2] == 'x') |
| type = FILE_EXEC; |
| else |
| type = FILE_NONEXEC; |
| } else if (filename[0] == '\0' || filename[0] == '\n') { |
| type = ANONYMOUS; |
| } else if (strcmp(filename, "[stack]") == 0) { |
| type = STACK; |
| } else { |
| type = OTHER; |
| } |
| // TODO(dmikurube): This |all_| count should be removed in future soon. |
| // See http://crbug.com/245603. |
| uint64 vma_total = all_[type].Record( |
| memory_residence_info_getter, vma_start_addr, vma_last_addr, NULL); |
| uint64 vma_subtotal = 0; |
| |
| // TODO(dmikurube): Stop double-counting pagemap. |
| // It will be fixed when http://crbug.com/245603 finishes. |
| if (MemoryRegionMap::IsRecordingLocked()) { |
| uint64 cursor = vma_start_addr; |
| bool first = true; |
| |
| // Iterates over MemoryRegionMap until the iterator moves out of the VMA. |
| do { |
| if (!first) { |
| cursor = mmap_iter->end_addr; |
| ++mmap_iter; |
| // Don't break here even if mmap_iter == EndRegionLocked(). |
| |
| if (mmap_iter != MemoryRegionMap::EndRegionLocked()) { |
| deep_bucket = GetInformationOfMemoryRegion( |
| mmap_iter, memory_residence_info_getter, deep_profile); |
| } |
| } |
| first = false; |
| |
| uint64 last_address_of_unhooked; |
| // If the next mmap entry is away from the current VMA. |
| if (mmap_iter == MemoryRegionMap::EndRegionLocked() || |
| mmap_iter->start_addr > vma_last_addr) { |
| last_address_of_unhooked = vma_last_addr; |
| } else { |
| last_address_of_unhooked = mmap_iter->start_addr - 1; |
| } |
| |
| if (last_address_of_unhooked + 1 > cursor) { |
| RAW_CHECK(cursor >= vma_start_addr, |
| "Wrong calculation for unhooked"); |
| RAW_CHECK(last_address_of_unhooked <= vma_last_addr, |
| "Wrong calculation for unhooked"); |
| uint64 committed_size = unhooked_[type].Record( |
| memory_residence_info_getter, |
| cursor, |
| last_address_of_unhooked, |
| mmap_dump_buffer); |
| vma_subtotal += committed_size; |
| if (mmap_dump_buffer) { |
| mmap_dump_buffer->AppendString(" ", 0); |
| mmap_dump_buffer->AppendPtr(cursor, 0); |
| mmap_dump_buffer->AppendString(" - ", 0); |
| mmap_dump_buffer->AppendPtr(last_address_of_unhooked + 1, 0); |
| mmap_dump_buffer->AppendString(" unhooked ", 0); |
| mmap_dump_buffer->AppendInt64(committed_size, 0); |
| mmap_dump_buffer->AppendString(" / ", 0); |
| mmap_dump_buffer->AppendInt64( |
| last_address_of_unhooked - cursor + 1, 0); |
| mmap_dump_buffer->AppendString("\n", 0); |
| } |
| cursor = last_address_of_unhooked + 1; |
| } |
| |
| if (mmap_iter != MemoryRegionMap::EndRegionLocked() && |
| mmap_iter->start_addr <= vma_last_addr && |
| mmap_dump_buffer) { |
| bool trailing = mmap_iter->start_addr < vma_start_addr; |
| bool continued = mmap_iter->end_addr - 1 > vma_last_addr; |
| uint64 partial_first_address, partial_last_address; |
| if (trailing) |
| partial_first_address = vma_start_addr; |
| else |
| partial_first_address = mmap_iter->start_addr; |
| if (continued) |
| partial_last_address = vma_last_addr; |
| else |
| partial_last_address = mmap_iter->end_addr - 1; |
| uint64 committed_size = 0; |
| if (memory_residence_info_getter) |
| committed_size = memory_residence_info_getter->CommittedSize( |
| partial_first_address, partial_last_address, mmap_dump_buffer); |
| vma_subtotal += committed_size; |
| mmap_dump_buffer->AppendString(trailing ? " (" : " ", 0); |
| mmap_dump_buffer->AppendPtr(mmap_iter->start_addr, 0); |
| mmap_dump_buffer->AppendString(trailing ? ")" : " ", 0); |
| mmap_dump_buffer->AppendString("-", 0); |
| mmap_dump_buffer->AppendString(continued ? "(" : " ", 0); |
| mmap_dump_buffer->AppendPtr(mmap_iter->end_addr, 0); |
| mmap_dump_buffer->AppendString(continued ? ")" : " ", 0); |
| mmap_dump_buffer->AppendString(" hooked ", 0); |
| mmap_dump_buffer->AppendInt64(committed_size, 0); |
| mmap_dump_buffer->AppendString(" / ", 0); |
| mmap_dump_buffer->AppendInt64( |
| partial_last_address - partial_first_address + 1, 0); |
| mmap_dump_buffer->AppendString(" @ ", 0); |
| if (deep_bucket != NULL) { |
| mmap_dump_buffer->AppendInt(deep_bucket->id, 0, false); |
| } else { |
| mmap_dump_buffer->AppendInt(0, 0, false); |
| } |
| mmap_dump_buffer->AppendString("\n", 0); |
| } |
| } while (mmap_iter != MemoryRegionMap::EndRegionLocked() && |
| mmap_iter->end_addr - 1 <= vma_last_addr); |
| } |
| |
| if (vma_total != vma_subtotal) { |
| char buffer[1024]; |
| int written = procmaps_iter.FormatLine(buffer, sizeof(buffer), |
| vma_start_addr, vma_last_addr, |
| flags, offset, inode, filename, 0); |
| RAW_VLOG(0, "[%d] Mismatched total in VMA %" PRId64 ":" |
| "%" PRId64 " (%" PRId64 ")", |
| getpid(), vma_total, vma_subtotal, vma_total - vma_subtotal); |
| RAW_VLOG(0, "[%d] in %s", getpid(), buffer); |
| } |
| } |
| |
| // TODO(dmikurube): Investigate and fix http://crbug.com/189114. |
| // |
| // The total committed memory usage in all_ (from /proc/<pid>/maps) is |
| // sometimes smaller than the sum of the committed mmap'ed addresses and |
| // unhooked regions. Within our observation, the difference was only 4KB |
| // in committed usage, zero in reserved virtual addresses |
| // |
| // A guess is that an uncommitted (but reserved) page may become committed |
| // during counting memory usage in the loop above. |
| // |
| // The difference is accounted as "ABSENT" to investigate such cases. |
| // |
| // It will be fixed when http://crbug.com/245603 finishes (no double count). |
| |
| RegionStats all_total; |
| RegionStats unhooked_total; |
| for (int i = 0; i < NUMBER_OF_MAPS_REGION_TYPES; ++i) { |
| all_total.AddAnotherRegionStat(all_[i]); |
| unhooked_total.AddAnotherRegionStat(unhooked_[i]); |
| } |
| |
| size_t absent_virtual = profiled_mmap_.virtual_bytes() + |
| unhooked_total.virtual_bytes() - |
| all_total.virtual_bytes(); |
| if (absent_virtual > 0) |
| all_[ABSENT].AddToVirtualBytes(absent_virtual); |
| |
| size_t absent_committed = profiled_mmap_.committed_bytes() + |
| unhooked_total.committed_bytes() - |
| all_total.committed_bytes(); |
| if (absent_committed > 0) |
| all_[ABSENT].AddToCommittedBytes(absent_committed); |
| } |
| |
| void DeepHeapProfile::GlobalStats::SnapshotAllocations( |
| DeepHeapProfile* deep_profile) { |
| profiled_malloc_.Initialize(); |
| |
| deep_profile->heap_profile_->address_map_->Iterate(RecordAlloc, deep_profile); |
| } |
| |
| void DeepHeapProfile::GlobalStats::Unparse(TextBuffer* buffer) { |
| RegionStats all_total; |
| RegionStats unhooked_total; |
| for (int i = 0; i < NUMBER_OF_MAPS_REGION_TYPES; ++i) { |
| all_total.AddAnotherRegionStat(all_[i]); |
| unhooked_total.AddAnotherRegionStat(unhooked_[i]); |
| } |
| |
| // "# total (%lu) %c= profiled-mmap (%lu) + nonprofiled-* (%lu)\n" |
| buffer->AppendString("# total (", 0); |
| buffer->AppendUnsignedLong(all_total.committed_bytes(), 0); |
| buffer->AppendString(") ", 0); |
| buffer->AppendChar(all_total.committed_bytes() == |
| profiled_mmap_.committed_bytes() + |
| unhooked_total.committed_bytes() ? '=' : '!'); |
| buffer->AppendString("= profiled-mmap (", 0); |
| buffer->AppendUnsignedLong(profiled_mmap_.committed_bytes(), 0); |
| buffer->AppendString(") + nonprofiled-* (", 0); |
| buffer->AppendUnsignedLong(unhooked_total.committed_bytes(), 0); |
| buffer->AppendString(")\n", 0); |
| |
| // " virtual committed" |
| buffer->AppendString("", 26); |
| buffer->AppendString(kVirtualLabel, 12); |
| buffer->AppendChar(' '); |
| buffer->AppendString(kCommittedLabel, 12); |
| buffer->AppendString("\n", 0); |
| |
| all_total.Unparse("total", buffer); |
| all_[ABSENT].Unparse("absent", buffer); |
| all_[FILE_EXEC].Unparse("file-exec", buffer); |
| all_[FILE_NONEXEC].Unparse("file-nonexec", buffer); |
| all_[ANONYMOUS].Unparse("anonymous", buffer); |
| all_[STACK].Unparse("stack", buffer); |
| all_[OTHER].Unparse("other", buffer); |
| unhooked_total.Unparse("nonprofiled-total", buffer); |
| unhooked_[ABSENT].Unparse("nonprofiled-absent", buffer); |
| unhooked_[ANONYMOUS].Unparse("nonprofiled-anonymous", buffer); |
| unhooked_[FILE_EXEC].Unparse("nonprofiled-file-exec", buffer); |
| unhooked_[FILE_NONEXEC].Unparse("nonprofiled-file-nonexec", buffer); |
| unhooked_[STACK].Unparse("nonprofiled-stack", buffer); |
| unhooked_[OTHER].Unparse("nonprofiled-other", buffer); |
| profiled_mmap_.Unparse("profiled-mmap", buffer); |
| profiled_malloc_.Unparse("profiled-malloc", buffer); |
| } |
| |
| // static |
| void DeepHeapProfile::GlobalStats::RecordAlloc(const void* pointer, |
| AllocValue* alloc_value, |
| DeepHeapProfile* deep_profile) { |
| uint64 address = reinterpret_cast<uintptr_t>(pointer); |
| size_t committed = deep_profile->memory_residence_info_getter_->CommittedSize( |
| address, address + alloc_value->bytes - 1, NULL); |
| |
| DeepBucket* deep_bucket = deep_profile->deep_table_.Lookup( |
| alloc_value->bucket(), |
| #if defined(TYPE_PROFILING) |
| LookupType(pointer), |
| #endif |
| /* is_mmap */ false); |
| deep_bucket->committed_size += committed; |
| deep_profile->stats_.profiled_malloc_.AddToVirtualBytes(alloc_value->bytes); |
| deep_profile->stats_.profiled_malloc_.AddToCommittedBytes(committed); |
| } |
| |
| DeepHeapProfile::DeepBucket* |
| DeepHeapProfile::GlobalStats::GetInformationOfMemoryRegion( |
| const MemoryRegionMap::RegionIterator& mmap_iter, |
| const MemoryResidenceInfoGetterInterface* memory_residence_info_getter, |
| DeepHeapProfile* deep_profile) { |
| size_t committed = deep_profile->memory_residence_info_getter_-> |
| CommittedSize(mmap_iter->start_addr, mmap_iter->end_addr - 1, NULL); |
| |
| // TODO(dmikurube): Store a reference to the bucket in region. |
| Bucket* bucket = MemoryRegionMap::GetBucket( |
| mmap_iter->call_stack_depth, mmap_iter->call_stack); |
| DeepBucket* deep_bucket = NULL; |
| if (bucket != NULL) { |
| deep_bucket = deep_profile->deep_table_.Lookup( |
| bucket, |
| #if defined(TYPE_PROFILING) |
| NULL, // No type information for memory regions by mmap. |
| #endif |
| /* is_mmap */ true); |
| if (deep_bucket != NULL) |
| deep_bucket->committed_size += committed; |
| } |
| |
| profiled_mmap_.AddToVirtualBytes( |
| mmap_iter->end_addr - mmap_iter->start_addr); |
| profiled_mmap_.AddToCommittedBytes(committed); |
| |
| return deep_bucket; |
| } |
| |
| // static |
| void DeepHeapProfile::WriteProcMaps(const char* prefix, |
| char raw_buffer[], |
| int buffer_size) { |
| char filename[100]; |
| snprintf(filename, sizeof(filename), |
| "%s.%05d.maps", prefix, static_cast<int>(getpid())); |
| |
| RawFD fd = RawOpenForWriting(filename); |
| RAW_DCHECK(fd != kIllegalRawFD, ""); |
| |
| int length; |
| bool wrote_all; |
| length = tcmalloc::FillProcSelfMaps(raw_buffer, buffer_size, &wrote_all); |
| RAW_DCHECK(wrote_all, ""); |
| RAW_DCHECK(length <= buffer_size, ""); |
| RawWrite(fd, raw_buffer, length); |
| RawClose(fd); |
| } |
| #else // USE_DEEP_HEAP_PROFILE |
| |
| DeepHeapProfile::DeepHeapProfile(HeapProfileTable* heap_profile, |
| const char* prefix, |
| enum PageFrameType pageframe_type) |
| : heap_profile_(heap_profile) { |
| } |
| |
| DeepHeapProfile::~DeepHeapProfile() { |
| } |
| |
| void DeepHeapProfile::DumpOrderedProfile(const char* reason, |
| char raw_buffer[], |
| int buffer_size, |
| RawFD fd) { |
| } |
| |
| #endif // USE_DEEP_HEAP_PROFILE |