mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-12-07 13:24:12 +00:00
d1a9b44ea6
I missed in bug 1487216 that the pres arena memory reporting assumes that the entry indices are frame class ids, which means that we're reporting some display list arena entries as frames, which is obviously wrong. Cleanup a bit nsPresArena to remove the custom id concept, and report also individual display item type memory usage. Differential Revision: https://phabricator.services.mozilla.com/D35368 --HG-- extra : moz-landing-system : lando
188 lines
7.2 KiB
C++
188 lines
7.2 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
|
|
/* 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/.
|
|
*/
|
|
|
|
/* arena allocation for the frame tree and closely-related objects */
|
|
|
|
#include "nsPresArena.h"
|
|
|
|
#include "mozilla/Poison.h"
|
|
#include "nsDebug.h"
|
|
#include "nsPrintfCString.h"
|
|
#include "FrameLayerBuilder.h"
|
|
#include "mozilla/ArrayUtils.h"
|
|
#include "mozilla/ComputedStyle.h"
|
|
#include "mozilla/ComputedStyleInlines.h"
|
|
#include "nsWindowSizes.h"
|
|
|
|
#include <inttypes.h>
|
|
|
|
using namespace mozilla;
|
|
|
|
template <size_t ArenaSize, typename ObjectId, size_t ObjectIdCount>
|
|
nsPresArena<ArenaSize, ObjectId, ObjectIdCount>::~nsPresArena() {
|
|
#if defined(MOZ_HAVE_MEM_CHECKS)
|
|
for (FreeList* entry = mFreeLists; entry != ArrayEnd(mFreeLists); ++entry) {
|
|
nsTArray<void*>::index_type len;
|
|
while ((len = entry->mEntries.Length())) {
|
|
void* result = entry->mEntries.ElementAt(len - 1);
|
|
entry->mEntries.RemoveElementAt(len - 1);
|
|
MOZ_MAKE_MEM_UNDEFINED(result, entry->mEntrySize);
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
template <size_t ArenaSize, typename ObjectId, size_t ObjectIdCount>
|
|
void* nsPresArena<ArenaSize, ObjectId, ObjectIdCount>::Allocate(ObjectId aCode,
|
|
size_t aSize) {
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
MOZ_ASSERT(aSize > 0, "PresArena cannot allocate zero bytes");
|
|
MOZ_ASSERT(size_t(aCode) < ArrayLength(mFreeLists));
|
|
|
|
// We only hand out aligned sizes
|
|
aSize = mPool.AlignedSize(aSize);
|
|
|
|
FreeList* list = &mFreeLists[size_t(aCode)];
|
|
|
|
nsTArray<void*>::index_type len = list->mEntries.Length();
|
|
if (list->mEntrySize == 0) {
|
|
MOZ_ASSERT(len == 0, "list with entries but no recorded size");
|
|
list->mEntrySize = aSize;
|
|
} else {
|
|
MOZ_ASSERT(list->mEntrySize == aSize,
|
|
"different sizes for same object type code");
|
|
}
|
|
|
|
void* result;
|
|
if (len > 0) {
|
|
// Remove from the end of the mEntries array to avoid memmoving entries,
|
|
// and use SetLengthAndRetainStorage to avoid a lot of malloc/free
|
|
// from ShrinkCapacity on smaller sizes. 500 pointers means the malloc size
|
|
// for the array is 4096 bytes or more on a 64-bit system. The next smaller
|
|
// size is 2048 (with jemalloc), which we consider not worth compacting.
|
|
result = list->mEntries.ElementAt(len - 1);
|
|
if (list->mEntries.Capacity() > 500) {
|
|
list->mEntries.RemoveElementAt(len - 1);
|
|
} else {
|
|
list->mEntries.SetLengthAndRetainStorage(len - 1);
|
|
}
|
|
#if defined(DEBUG)
|
|
{
|
|
MOZ_MAKE_MEM_DEFINED(result, list->mEntrySize);
|
|
char* p = reinterpret_cast<char*>(result);
|
|
char* limit = p + list->mEntrySize;
|
|
for (; p < limit; p += sizeof(uintptr_t)) {
|
|
uintptr_t val = *reinterpret_cast<uintptr_t*>(p);
|
|
if (val != mozPoisonValue()) {
|
|
MOZ_ReportAssertionFailure(
|
|
nsPrintfCString("PresArena: poison overwritten; "
|
|
"wanted %.16" PRIx64 " "
|
|
"found %.16" PRIx64 " "
|
|
"errors in bits %.16" PRIx64 " ",
|
|
uint64_t(mozPoisonValue()), uint64_t(val),
|
|
uint64_t(mozPoisonValue() ^ val))
|
|
.get(),
|
|
__FILE__, __LINE__);
|
|
MOZ_CRASH();
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
MOZ_MAKE_MEM_UNDEFINED(result, list->mEntrySize);
|
|
return result;
|
|
}
|
|
|
|
// Allocate a new chunk from the arena
|
|
list->mEntriesEverAllocated++;
|
|
return mPool.Allocate(aSize);
|
|
}
|
|
|
|
template <size_t ArenaSize, typename ObjectId, size_t ObjectIdCount>
|
|
void nsPresArena<ArenaSize, ObjectId, ObjectIdCount>::Free(ObjectId aCode,
|
|
void* aPtr) {
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
MOZ_ASSERT(size_t(aCode) < ArrayLength(mFreeLists));
|
|
|
|
// Try to recycle this entry.
|
|
FreeList* list = &mFreeLists[size_t(aCode)];
|
|
MOZ_ASSERT(list->mEntrySize > 0, "object of this type was never allocated");
|
|
|
|
mozWritePoison(aPtr, list->mEntrySize);
|
|
|
|
MOZ_MAKE_MEM_NOACCESS(aPtr, list->mEntrySize);
|
|
list->mEntries.AppendElement(aPtr);
|
|
}
|
|
|
|
template <size_t ArenaSize, typename ObjectId, size_t ObjectIdCount>
|
|
void nsPresArena<ArenaSize, ObjectId, ObjectIdCount>::AddSizeOfExcludingThis(
|
|
nsWindowSizes& aSizes, ArenaKind aKind) const {
|
|
// We do a complicated dance here because we want to measure the
|
|
// space taken up by the different kinds of objects in the arena,
|
|
// but we don't have pointers to those objects. And even if we did,
|
|
// we wouldn't be able to use mMallocSizeOf on them, since they were
|
|
// allocated out of malloc'd chunks of memory. So we compute the
|
|
// size of the arena as known by malloc and we add up the sizes of
|
|
// all the objects that we care about. Subtracting these two
|
|
// quantities gives us a catch-all "other" number, which includes
|
|
// slop in the arena itself as well as the size of objects that
|
|
// we've not measured explicitly.
|
|
|
|
size_t mallocSize = mPool.SizeOfExcludingThis(aSizes.mState.mMallocSizeOf);
|
|
|
|
size_t totalSizeInFreeLists = 0;
|
|
for (const FreeList* entry = mFreeLists; entry != ArrayEnd(mFreeLists);
|
|
++entry) {
|
|
mallocSize += entry->SizeOfExcludingThis(aSizes.mState.mMallocSizeOf);
|
|
|
|
// Note that we're not measuring the size of the entries on the free
|
|
// list here. The free list knows how many objects we've allocated
|
|
// ever (which includes any objects that may be on the FreeList's
|
|
// |mEntries| at this point) and we're using that to determine the
|
|
// total size of objects allocated with a given ID.
|
|
size_t totalSize = entry->mEntrySize * entry->mEntriesEverAllocated;
|
|
|
|
if (aKind == ArenaKind::PresShell) {
|
|
switch (entry - mFreeLists) {
|
|
#define PRES_ARENA_OBJECT(name_) \
|
|
case eArenaObjectID_##name_: \
|
|
aSizes.mArenaSizes.NS_ARENA_SIZES_FIELD(name_) += totalSize; \
|
|
break;
|
|
#include "nsPresArenaObjectList.h"
|
|
#undef PRES_ARENA_OBJECT
|
|
default:
|
|
MOZ_ASSERT_UNREACHABLE("Unknown arena object type");
|
|
}
|
|
} else {
|
|
MOZ_ASSERT(aKind == ArenaKind::DisplayList);
|
|
switch (DisplayListArenaObjectId(entry - mFreeLists)) {
|
|
#define DISPLAY_LIST_ARENA_OBJECT(name_) \
|
|
case DisplayListArenaObjectId::name_: \
|
|
aSizes.mArenaSizes.NS_ARENA_SIZES_FIELD(name_) += totalSize; \
|
|
break;
|
|
#include "nsDisplayListArenaTypes.h"
|
|
#undef DISPLAY_LIST_ARENA_OBJECT
|
|
default:
|
|
MOZ_ASSERT_UNREACHABLE("Unknown display item arena type");
|
|
}
|
|
}
|
|
|
|
totalSizeInFreeLists += totalSize;
|
|
}
|
|
|
|
auto& field = aKind == ArenaKind::PresShell
|
|
? aSizes.mLayoutPresShellSize
|
|
: aSizes.mLayoutRetainedDisplayListSize;
|
|
|
|
field += mallocSize - totalSizeInFreeLists;
|
|
}
|
|
|
|
// Explicitly instantiate templates for the used nsPresArena allocator sizes.
|
|
// This is needed because nsPresArena definition is split across multiple files.
|
|
template class nsPresArena<8192, ArenaObjectID, eArenaObjectID_COUNT>;
|
|
template class nsPresArena<32768, DisplayListArenaObjectId,
|
|
size_t(DisplayListArenaObjectId::COUNT)>;
|