mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-31 22:25:30 +00:00
b0d0022c36
There are three categories of improvements:
(1) using size_t* rather than unsigned long* (and "%zX" rather than
"%lX"), to better support platforms where sizeof(long) !=
sizeof(void*), such as Win64 (untested, though). This is a
non-issue for 64-bit Linux (where I tested) and Mac.
(2) Using the correct amount of 0-padding when printing addresses to
show how much memory space is being printed. In other words, using
"%016zX" on 64-bit platforms instead of "%08zX". This change is
cosmetic-only, though it makes the logs much more understandable.
(3) [in leaksoup.cpp only] Fixing an occurrence of assuming that
sizeof(int) == sizeof(void*). This occurrence led to printing only
the lower half of each word in the output, after doing a correct
analysis of the memory graph.
This patch is patching three files:
(A) nsTraceMalloc.cpp, which is the in-process Gecko trace-malloc code
that generates the memory dumps.
(B) adreader.cpp, which is shared utility code for reading such a
memory dump (currently used only by leaksoup.cpp)
(C) leaksoup.cpp, which reads in such a memory dump, performs a
strongly connected components analysis of the memory graph, and
writes it back out, HTML-ized, with the roots listed at the top.
A fourth file appears to need no modification since it only looks at the
stack part of the dump and not the contents of the memory:
(D) diffbloatdump.pl, which diffs two bloat dumps and produces a stack
tree showing the change in allocations between them
133 lines
3.3 KiB
C++
133 lines
3.3 KiB
C++
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#include "adreader.h"
|
|
|
|
#include <stdio.h>
|
|
#include <stdint.h>
|
|
#include <string.h>
|
|
|
|
ADLog::ADLog()
|
|
: mEntryCount(0)
|
|
{
|
|
mEntries.mNext = static_cast<EntryBlock*>(&mEntries);
|
|
mEntries.mPrev = static_cast<EntryBlock*>(&mEntries);
|
|
}
|
|
|
|
ADLog::~ADLog()
|
|
{
|
|
for (const_iterator entry = begin(), entry_end = end();
|
|
entry != entry_end; ++entry) {
|
|
free((void*) (*entry)->type);
|
|
free((char*) (*entry)->data);
|
|
free((char*) (*entry)->allocation_stack);
|
|
}
|
|
|
|
for (EntryBlock *b = mEntries.mNext, *next; b != &mEntries; b = next) {
|
|
next = b->mNext;
|
|
delete b;
|
|
}
|
|
}
|
|
|
|
bool
|
|
ADLog::Read(const char* aFileName)
|
|
{
|
|
FILE *in = fopen(aFileName, "r");
|
|
if (!in) {
|
|
return false;
|
|
}
|
|
|
|
while (!feof(in)) {
|
|
unsigned int ptr;
|
|
char typebuf[256];
|
|
int datasize;
|
|
int res = fscanf(in, "%x %s (%d)\n", &ptr, typebuf, &datasize);
|
|
if (res == EOF)
|
|
break;
|
|
if (res != 3) {
|
|
return false;
|
|
}
|
|
|
|
size_t data_mem_size = ((datasize + sizeof(unsigned long) - 1) /
|
|
sizeof(unsigned long)) * sizeof(unsigned long);
|
|
char *data = (char*)malloc(data_mem_size);
|
|
|
|
for (size_t *cur_data = (size_t*) data,
|
|
*cur_data_end = (size_t*) ((char*)data + data_mem_size);
|
|
cur_data != cur_data_end; ++cur_data) {
|
|
res = fscanf(in, " %zX\n", cur_data);
|
|
if (res != 1) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
char stackbuf[100000];
|
|
stackbuf[0] = '\0';
|
|
|
|
char *stack = stackbuf;
|
|
int len;
|
|
do {
|
|
fgets(stack, sizeof(stackbuf) - (stack - stackbuf), in);
|
|
len = strlen(stack);
|
|
stack += len;
|
|
} while (len > 1);
|
|
|
|
if (mEntryCount % ADLOG_ENTRY_BLOCK_SIZE == 0) {
|
|
EntryBlock *new_block = new EntryBlock();
|
|
new_block->mNext = static_cast<EntryBlock*>(&mEntries);
|
|
new_block->mPrev = mEntries.mPrev;
|
|
mEntries.mPrev->mNext = new_block;
|
|
mEntries.mPrev = new_block;
|
|
}
|
|
|
|
size_t typelen = strlen(typebuf);
|
|
char *type = (char*)malloc(typelen-1);
|
|
strncpy(type, typebuf+1, typelen-2);
|
|
type[typelen-2] = '\0';
|
|
|
|
Entry *entry =
|
|
&mEntries.mPrev->entries[mEntryCount % ADLOG_ENTRY_BLOCK_SIZE];
|
|
entry->address = (Pointer) (uintptr_t) ptr;
|
|
entry->type = type;
|
|
entry->datasize = datasize;
|
|
entry->data = data;
|
|
entry->allocation_stack = strdup(stackbuf);
|
|
|
|
++mEntryCount;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
ADLog::const_iterator::const_iterator(ADLog::EntryBlock *aBlock,
|
|
size_t aOffset)
|
|
{
|
|
SetBlock(aBlock);
|
|
mCur = mBlockStart + aOffset;
|
|
}
|
|
|
|
ADLog::const_iterator&
|
|
ADLog::const_iterator::operator++()
|
|
{
|
|
++mCur;
|
|
if (mCur == mBlockEnd) {
|
|
SetBlock(mBlock->mNext);
|
|
mCur = mBlockStart;
|
|
}
|
|
|
|
return *this;
|
|
}
|
|
|
|
ADLog::const_iterator&
|
|
ADLog::const_iterator::operator--()
|
|
{
|
|
if (mCur == mBlockStart) {
|
|
SetBlock(mBlock->mPrev);
|
|
mCur = mBlockEnd;
|
|
}
|
|
--mCur;
|
|
|
|
return *this;
|
|
}
|