wine/gecko
0
0
Fork 0
mirror of https://gitlab.winehq.org/wine/wine-gecko.git synced 2024-09-13 09:24:08 -07:00
Code Issues Packages Projects Releases Wiki Activity

Bug 920852 (part 1) - Rename fields of ObjectsExtraSizes and CompartmentStats to match memory reporter paths. r=till.

Browse Source 
--HG--
extra : rebase_source : 0f55dd20e69d3410d0cb811529f53570f588cc5e
This commit is contained in:
Nicholas Nethercote 2013-09-24 23:24:28 -07:00
parent 94c6803786
commit 7d3e82240b
4 changed files with 94 additions and 93 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

50
js/public/MemoryMetrics.h
View File

@ -115,16 +115,16 @@ namespace JS {
struct ObjectsExtraSizes
{
#define FOR_EACH_SIZE(macro) \
macro(js::NotLiveGCThing, slots) \
macro(js::NotLiveGCThing, elementsNonAsmJS) \
macro(js::NotLiveGCThing, elementsAsmJSHeap) \
macro(js::NotLiveGCThing, elementsAsmJSNonHeap) \
macro(js::NotLiveGCThing, asmJSModuleCode) \
macro(js::NotLiveGCThing, asmJSModuleData) \
macro(js::NotLiveGCThing, argumentsData) \
macro(js::NotLiveGCThing, regExpStatics) \
macro(js::NotLiveGCThing, propertyIteratorData) \
macro(js::NotLiveGCThing, ctypesData)
macro(js::NotLiveGCThing, mallocHeapSlots) \
macro(js::NotLiveGCThing, mallocHeapElementsNonAsmJS) \
macro(js::NotLiveGCThing, mallocHeapElementsAsmJS) \
macro(js::NotLiveGCThing, nonHeapElementsAsmJS) \
macro(js::NotLiveGCThing, nonHeapCodeAsmJS) \
macro(js::NotLiveGCThing, mallocHeapAsmJSModuleData) \
macro(js::NotLiveGCThing, mallocHeapArgumentsData) \
macro(js::NotLiveGCThing, mallocHeapRegExpStatics) \
macro(js::NotLiveGCThing, mallocHeapPropertyIteratorData) \
macro(js::NotLiveGCThing, mallocHeapCtypesData)
ObjectsExtraSizes()
: FOR_EACH_SIZE(ZERO_SIZE)
@ -359,22 +359,22 @@ struct ZoneStats : js::ZoneStatsPod
struct CompartmentStats
{
#define FOR_EACH_SIZE(macro) \
macro(js::IsLiveGCThing, gcHeapObjectsOrdinary) \
macro(js::IsLiveGCThing, gcHeapObjectsFunction) \
macro(js::IsLiveGCThing, gcHeapObjectsDenseArray) \
macro(js::IsLiveGCThing, gcHeapObjectsSlowArray) \
macro(js::IsLiveGCThing, gcHeapObjectsCrossCompartmentWrapper) \
macro(js::IsLiveGCThing, gcHeapShapesTreeGlobalParented) \
macro(js::IsLiveGCThing, gcHeapShapesTreeNonGlobalParented) \
macro(js::IsLiveGCThing, gcHeapShapesDict) \
macro(js::IsLiveGCThing, gcHeapShapesBase) \
macro(js::IsLiveGCThing, gcHeapScripts) \
macro(js::IsLiveGCThing, objectsGCHeapOrdinary) \
macro(js::IsLiveGCThing, objectsGCHeapFunction) \
macro(js::IsLiveGCThing, objectsGCHeapDenseArray) \
macro(js::IsLiveGCThing, objectsGCHeapSlowArray) \
macro(js::IsLiveGCThing, objectsGCHeapCrossCompartmentWrapper) \
macro(js::IsLiveGCThing, shapesGCHeapTreeGlobalParented) \
macro(js::IsLiveGCThing, shapesGCHeapTreeNonGlobalParented) \
macro(js::IsLiveGCThing, shapesGCHeapDict) \
macro(js::IsLiveGCThing, shapesGCHeapBase) \
macro(js::IsLiveGCThing, scriptsGCHeap) \
macro(js::NotLiveGCThing, objectsPrivate) \
macro(js::NotLiveGCThing, shapesExtraTreeTables) \
macro(js::NotLiveGCThing, shapesExtraDictTables) \
macro(js::NotLiveGCThing, shapesExtraTreeShapeKids) \
macro(js::NotLiveGCThing, shapesCompartmentTables) \
macro(js::NotLiveGCThing, scriptData) \
macro(js::NotLiveGCThing, shapesMallocHeapTreeTables) \
macro(js::NotLiveGCThing, shapesMallocHeapDictTables) \
macro(js::NotLiveGCThing, shapesMallocHeapTreeShapeKids) \
macro(js::NotLiveGCThing, shapesMallocHeapCompartmentTables) \
macro(js::NotLiveGCThing, scriptsMallocHeapData) \
macro(js::NotLiveGCThing, baselineData) \
macro(js::NotLiveGCThing, baselineStubsFallback) \
macro(js::NotLiveGCThing, baselineStubsOptimized) \

21
js/src/jsobj.cpp
View File

@ -5560,7 +5560,7 @@ void
JSObject::sizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf, JS::ObjectsExtraSizes *sizes)
{
if (hasDynamicSlots())
sizes->slots = mallocSizeOf(slots);
sizes->mallocHeapSlots = mallocSizeOf(slots);
if (hasDynamicElements()) {
js::ObjectElements *elements = getElementsHeader();
@ -5568,32 +5568,33 @@ JSObject::sizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf, JS::ObjectsExt
#if defined (JS_CPU_X64)
// On x64, ArrayBufferObject::prepareForAsmJS switches the
// ArrayBufferObject to use mmap'd storage.
sizes->elementsAsmJSNonHeap = as<ArrayBufferObject>().byteLength();
sizes->nonHeapElementsAsmJS = as<ArrayBufferObject>().byteLength();
#else
sizes->elementsAsmJSHeap = mallocSizeOf(elements);
sizes->mallocHeapElementsAsmJS = mallocSizeOf(elements);
#endif
} else {
sizes->elementsNonAsmJS = mallocSizeOf(elements);
sizes->mallocHeapElementsNonAsmJS = mallocSizeOf(elements);
}
}
// Other things may be measured in the future if DMD indicates it is worthwhile.
// Note that sizes->private_ is measured elsewhere.
if (is<ArgumentsObject>()) {
sizes->argumentsData = as<ArgumentsObject>().sizeOfMisc(mallocSizeOf);
sizes->mallocHeapArgumentsData = as<ArgumentsObject>().sizeOfMisc(mallocSizeOf);
} else if (is<RegExpStaticsObject>()) {
sizes->regExpStatics = as<RegExpStaticsObject>().sizeOfData(mallocSizeOf);
sizes->mallocHeapRegExpStatics = as<RegExpStaticsObject>().sizeOfData(mallocSizeOf);
} else if (is<PropertyIteratorObject>()) {
sizes->propertyIteratorData = as<PropertyIteratorObject>().sizeOfMisc(mallocSizeOf);
sizes->mallocHeapPropertyIteratorData = as<PropertyIteratorObject>().sizeOfMisc(mallocSizeOf);
#ifdef JS_ION
} else if (is<AsmJSModuleObject>()) {
as<AsmJSModuleObject>().sizeOfMisc(mallocSizeOf, &sizes->asmJSModuleCode,
&sizes->asmJSModuleData);
as<AsmJSModuleObject>().sizeOfMisc(mallocSizeOf, &sizes->nonHeapCodeAsmJS,
&sizes->mallocHeapAsmJSModuleData);
#endif
#ifdef JS_HAS_CTYPES
} else {
// This must be the last case.
sizes->ctypesData = js::SizeOfDataIfCDataObject(mallocSizeOf, const_cast<JSObject *>(this));
sizes->mallocHeapCtypesData =
js::SizeOfDataIfCDataObject(mallocSizeOf, const_cast<JSObject *>(this));
#endif
}
}

28
js/src/vm/MemoryMetrics.cpp
View File

@ -197,7 +197,7 @@ StatsCompartmentCallback(JSRuntime *rt, void *data, JSCompartment *compartment)
compartment->sizeOfIncludingThis(rtStats->mallocSizeOf_,
&cStats.compartmentObject,
&cStats.typeInference,
&cStats.shapesCompartmentTables,
&cStats.shapesMallocHeapCompartmentTables,
&cStats.crossCompartmentWrappersTable,
&cStats.regexpCompartment,
&cStats.debuggeesSet,
@ -256,13 +256,13 @@ StatsCellCallback(JSRuntime *rt, void *data, void *thing, JSGCTraceKind traceKin
JSObject *obj = static_cast<JSObject *>(thing);
CompartmentStats *cStats = GetCompartmentStats(obj->compartment());
if (obj->is<JSFunction>())
cStats->gcHeapObjectsFunction += thingSize;
cStats->objectsGCHeapFunction += thingSize;
else if (obj->is<ArrayObject>())
cStats->gcHeapObjectsDenseArray += thingSize;
cStats->objectsGCHeapDenseArray += thingSize;
else if (obj->is<CrossCompartmentWrapperObject>())
cStats->gcHeapObjectsCrossCompartmentWrapper += thingSize;
cStats->objectsGCHeapCrossCompartmentWrapper += thingSize;
else
cStats->gcHeapObjectsOrdinary += thingSize;
cStats->objectsGCHeapOrdinary += thingSize;
JS::ObjectsExtraSizes objectsExtra;
obj->sizeOfExcludingThis(rtStats->mallocSizeOf_, &objectsExtra);
@ -310,17 +310,17 @@ StatsCellCallback(JSRuntime *rt, void *data, void *thing, JSGCTraceKind traceKin
size_t propTableSize, kidsSize;
shape->sizeOfExcludingThis(rtStats->mallocSizeOf_, &propTableSize, &kidsSize);
if (shape->inDictionary()) {
cStats->gcHeapShapesDict += thingSize;
cStats->shapesExtraDictTables += propTableSize;
cStats->shapesGCHeapDict += thingSize;
cStats->shapesMallocHeapDictTables += propTableSize;
JS_ASSERT(kidsSize == 0);
} else {
JSObject *parent = shape->base()->getObjectParent();
if (parent && parent->is<GlobalObject>())
cStats->gcHeapShapesTreeGlobalParented += thingSize;
cStats->shapesGCHeapTreeGlobalParented += thingSize;
else
cStats->gcHeapShapesTreeNonGlobalParented += thingSize;
cStats->shapesExtraTreeTables += propTableSize;
cStats->shapesExtraTreeShapeKids += kidsSize;
cStats->shapesGCHeapTreeNonGlobalParented += thingSize;
cStats->shapesMallocHeapTreeTables += propTableSize;
cStats->shapesMallocHeapTreeShapeKids += kidsSize;
}
break;
}
@ -328,15 +328,15 @@ StatsCellCallback(JSRuntime *rt, void *data, void *thing, JSGCTraceKind traceKin
case JSTRACE_BASE_SHAPE: {
BaseShape *base = static_cast<BaseShape *>(thing);
CompartmentStats *cStats = GetCompartmentStats(base->compartment());
cStats->gcHeapShapesBase += thingSize;
cStats->shapesGCHeapBase += thingSize;
break;
}
case JSTRACE_SCRIPT: {
JSScript *script = static_cast<JSScript *>(thing);
CompartmentStats *cStats = GetCompartmentStats(script->compartment());
cStats->gcHeapScripts += thingSize;
cStats->scriptData += script->sizeOfData(rtStats->mallocSizeOf_);
cStats->scriptsGCHeap += thingSize;
cStats->scriptsMallocHeapData += script->sizeOfData(rtStats->mallocSizeOf_);
#ifdef JS_ION
size_t baselineData = 0, baselineStubsFallback = 0;
jit::SizeOfBaselineData(script, rtStats->mallocSizeOf_, &baselineData,

88
js/xpconnect/src/XPCJSRuntime.cpp
View File

@ -1699,7 +1699,7 @@ private:
_desc, closure); \
NS_ENSURE_SUCCESS(rv, rv); \
} else { \
otherSundries += amount; \
sundriesMallocHeap += amount; \
} \
} while (0)
@ -1715,7 +1715,7 @@ private:
NS_ENSURE_SUCCESS(rv, rv); \
gcTotal += amount; \
} else { \
gcHeapSundries += amount; \
sundriesGCHeap += amount; \
} \
} while (0)
@ -1742,7 +1742,7 @@ ReportZoneStats(const JS::ZoneStats &zStats,
nsISupports *closure, size_t *gcTotalOut = NULL)
{
const nsAutoCString& pathPrefix = extras.pathPrefix;
size_t gcTotal = 0, gcHeapSundries = 0, otherSundries = 0;
size_t gcTotal = 0, sundriesGCHeap = 0, sundriesMallocHeap = 0;
ZCREPORT_GC_BYTES(pathPrefix + NS_LITERAL_CSTRING("gc-heap-arena-admin"),
zStats.gcHeapArenaAdmin,
@ -1894,18 +1894,18 @@ ReportZoneStats(const JS::ZoneStats &zStats,
"refresh about:memory.");
}
if (gcHeapSundries > 0) {
if (sundriesGCHeap > 0) {
// We deliberately don't use ZCREPORT_GC_BYTES here.
REPORT_GC_BYTES(pathPrefix + NS_LITERAL_CSTRING("sundries/gc-heap"),
gcHeapSundries,
sundriesGCHeap,
"The sum of all the 'gc-heap' measurements that are too "
"small to be worth showing individually.");
}
if (otherSundries > 0) {
if (sundriesMallocHeap > 0) {
// We deliberately don't use ZCREPORT_BYTES here.
REPORT_BYTES(pathPrefix + NS_LITERAL_CSTRING("sundries/malloc-heap"),
KIND_HEAP, otherSundries,
KIND_HEAP, sundriesMallocHeap,
"The sum of all the 'malloc-heap' measurements that are too "
"small to be worth showing individually.");
}
@ -1927,7 +1927,7 @@ ReportCompartmentStats(const JS::CompartmentStats &cStats,
{
static const nsDependentCString addonPrefix("explicit/add-ons/");
size_t gcTotal = 0, gcHeapSundries = 0, otherSundries = 0;
size_t gcTotal = 0, sundriesGCHeap = 0, sundriesMallocHeap = 0;
nsAutoCString cJSPathPrefix = extras.jsPathPrefix;
nsAutoCString cDOMPathPrefix = extras.domPathPrefix;
@ -1951,62 +1951,62 @@ ReportCompartmentStats(const JS::CompartmentStats &cStats,
}
ZCREPORT_GC_BYTES(cJSPathPrefix + NS_LITERAL_CSTRING("objects/gc-heap/ordinary"),
cStats.gcHeapObjectsOrdinary,
cStats.objectsGCHeapOrdinary,
"Memory on the garbage-collected JavaScript "
"heap that holds ordinary (i.e. not otherwise distinguished "
"my memory reporters) objects.");
ZCREPORT_GC_BYTES(cJSPathPrefix + NS_LITERAL_CSTRING("objects/gc-heap/function"),
cStats.gcHeapObjectsFunction,
cStats.objectsGCHeapFunction,
"Memory on the garbage-collected JavaScript "
"heap that holds function objects.");
ZCREPORT_GC_BYTES(cJSPathPrefix + NS_LITERAL_CSTRING("objects/gc-heap/dense-array"),
cStats.gcHeapObjectsDenseArray,
cStats.objectsGCHeapDenseArray,
"Memory on the garbage-collected JavaScript "
"heap that holds dense array objects.");
ZCREPORT_GC_BYTES(cJSPathPrefix + NS_LITERAL_CSTRING("objects/gc-heap/slow-array"),
cStats.gcHeapObjectsSlowArray,
cStats.objectsGCHeapSlowArray,
"Memory on the garbage-collected JavaScript "
"heap that holds slow array objects.");
ZCREPORT_GC_BYTES(cJSPathPrefix + NS_LITERAL_CSTRING("objects/gc-heap/cross-compartment-wrapper"),
cStats.gcHeapObjectsCrossCompartmentWrapper,
cStats.objectsGCHeapCrossCompartmentWrapper,
"Memory on the garbage-collected JavaScript "
"heap that holds cross-compartment wrapper objects.");
ZCREPORT_GC_BYTES(cJSPathPrefix + NS_LITERAL_CSTRING("scripts/gc-heap"),
cStats.gcHeapScripts,
cStats.scriptsGCHeap,
"Memory on the garbage-collected JavaScript "
"heap that holds JSScript instances. A JSScript is "
"created for each user-defined function in a script. One "
"is also created for the top-level code in a script.");
ZCREPORT_GC_BYTES(cJSPathPrefix + NS_LITERAL_CSTRING("shapes/gc-heap/tree/global-parented"),
cStats.gcHeapShapesTreeGlobalParented,
cStats.shapesGCHeapTreeGlobalParented,
"Memory on the garbage-collected JavaScript heap that "
"holds shapes that (a) are in a property tree, and (b) "
"represent an object whose parent is the global object.");
ZCREPORT_GC_BYTES(cJSPathPrefix + NS_LITERAL_CSTRING("shapes/gc-heap/tree/non-global-parented"),
cStats.gcHeapShapesTreeNonGlobalParented,
cStats.shapesGCHeapTreeNonGlobalParented,
"Memory on the garbage-collected JavaScript heap that "
"holds shapes that (a) are in a property tree, and (b) "
"represent an object whose parent is not the global object.");
ZCREPORT_GC_BYTES(cJSPathPrefix + NS_LITERAL_CSTRING("shapes/gc-heap/dict"),
cStats.gcHeapShapesDict,
cStats.shapesGCHeapDict,
"Memory on the garbage-collected JavaScript "
"heap that holds shapes that are in dictionary mode.");
ZCREPORT_GC_BYTES(cJSPathPrefix + NS_LITERAL_CSTRING("shapes/gc-heap/base"),
cStats.gcHeapShapesBase,
cStats.shapesGCHeapBase,
"Memory on the garbage-collected JavaScript "
"heap that collates data common to many shapes.");
ZCREPORT_BYTES(cJSPathPrefix + NS_LITERAL_CSTRING("objects/malloc-heap/slots"),
cStats.objectsExtra.slots,
cStats.objectsExtra.mallocHeapSlots,
"Memory allocated on the malloc heap for the non-fixed object "
"slot arrays, which are used to represent object properties. "
"Some objects also contain a fixed number of slots which are "
@ -2014,53 +2014,53 @@ ReportCompartmentStats(const JS::CompartmentStats &cStats,
"are not counted here, but in 'objects/gc-heap/*' instead.");
ZCREPORT_BYTES(cJSPathPrefix + NS_LITERAL_CSTRING("objects/malloc-heap/elements/non-asm.js"),
cStats.objectsExtra.elementsNonAsmJS,
cStats.objectsExtra.mallocHeapElementsNonAsmJS,
"Memory allocated on the malloc heap for non-asm.js object element arrays, "
"which are used to represent indexed object properties.");
// asm.js arrays are heap-allocated on some platforms and
// non-heap-allocated on others. We never put them under sundries,
// because (a) in practice they're almost always larger than the sundries
// threshold, and (b) we'd need a third category of non-heap, non-GC
// sundries, which would be a pain.
size_t asmJSHeap = cStats.objectsExtra.elementsAsmJSHeap;
size_t asmJSNonHeap = cStats.objectsExtra.elementsAsmJSNonHeap;
MOZ_ASSERT(asmJSHeap == 0 || asmJSNonHeap == 0);
if (asmJSHeap > 0) {
// threshold, and (b) we'd need a third category of sundries ("non-heap"),
// which would be a pain.
size_t mallocHeapElementsAsmJS = cStats.objectsExtra.mallocHeapElementsAsmJS;
size_t nonHeapElementsAsmJS = cStats.objectsExtra.nonHeapElementsAsmJS;
MOZ_ASSERT(mallocHeapElementsAsmJS == 0 || nonHeapElementsAsmJS == 0);
if (mallocHeapElementsAsmJS > 0) {
REPORT_BYTES(cJSPathPrefix + NS_LITERAL_CSTRING("objects/malloc-heap/elements/asm.js"),
KIND_HEAP, asmJSHeap,
KIND_HEAP, mallocHeapElementsAsmJS,
"Memory allocated on the malloc heap for object element arrays used as asm.js "
"array buffers.");
}
if (asmJSNonHeap > 0) {
if (nonHeapElementsAsmJS > 0) {
REPORT_BYTES(cJSPathPrefix + NS_LITERAL_CSTRING("objects/non-heap/elements/asm.js"),
KIND_NONHEAP, asmJSNonHeap,
KIND_NONHEAP, nonHeapElementsAsmJS,
"Memory allocated for object element arrays used as asm.js array buffers. "
"This memory lives outside both the malloc heap and the JS heap.");
}
REPORT_BYTES(cJSPathPrefix + NS_LITERAL_CSTRING("objects/non-heap/code/asm.js"),
KIND_NONHEAP, cStats.objectsExtra.asmJSModuleCode,
KIND_NONHEAP, cStats.objectsExtra.nonHeapCodeAsmJS,
"Memory allocated for AOT-compiled asm.js code.");
ZCREPORT_BYTES(cJSPathPrefix + NS_LITERAL_CSTRING("objects/malloc-heap/asm.js-module-data"),
cStats.objectsExtra.asmJSModuleData,
cStats.objectsExtra.mallocHeapAsmJSModuleData,
"Memory allocated for asm.js module data.");
ZCREPORT_BYTES(cJSPathPrefix + NS_LITERAL_CSTRING("objects/malloc-heap/arguments-data"),
cStats.objectsExtra.argumentsData,
cStats.objectsExtra.mallocHeapArgumentsData,
"Memory allocated on the malloc heap for data belonging to arguments objects.");
ZCREPORT_BYTES(cJSPathPrefix + NS_LITERAL_CSTRING("objects/malloc-heap/regexp-statics"),
cStats.objectsExtra.regExpStatics,
cStats.objectsExtra.mallocHeapRegExpStatics,
"Memory allocated for data belonging to the RegExpStatics object.");
ZCREPORT_BYTES(cJSPathPrefix + NS_LITERAL_CSTRING("objects/malloc-heap/property-iterator-data"),
cStats.objectsExtra.propertyIteratorData,
cStats.objectsExtra.mallocHeapPropertyIteratorData,
"Memory allocated on the malloc heap for data belonging to property iterator objects.");
ZCREPORT_BYTES(cJSPathPrefix + NS_LITERAL_CSTRING("objects/malloc-heap/ctypes-data"),
cStats.objectsExtra.ctypesData,
cStats.objectsExtra.mallocHeapCtypesData,
"Memory allocated on the malloc heap for data belonging to ctypes objects.");
// Note that we use cDOMPathPrefix here. This is because we measure orphan
@ -2072,27 +2072,27 @@ ReportCompartmentStats(const JS::CompartmentStats &cStats,
"from JavaScript objects.");
ZCREPORT_BYTES(cJSPathPrefix + NS_LITERAL_CSTRING("shapes/malloc-heap/tree-tables"),
cStats.shapesExtraTreeTables,
cStats.shapesMallocHeapTreeTables,
"Memory allocated on the malloc heap for the property tables "
"that belong to shapes that are in a property tree.");
ZCREPORT_BYTES(cJSPathPrefix + NS_LITERAL_CSTRING("shapes/malloc-heap/dict-tables"),
cStats.shapesExtraDictTables,
cStats.shapesMallocHeapDictTables,
"Memory allocated on the malloc heap for the property tables "
"that belong to shapes that are in dictionary mode.");
ZCREPORT_BYTES(cJSPathPrefix + NS_LITERAL_CSTRING("shapes/malloc-heap/tree-shape-kids"),
cStats.shapesExtraTreeShapeKids,
cStats.shapesMallocHeapTreeShapeKids,
"Memory allocated on the malloc heap for the kid hashes that "
"belong to shapes that are in a property tree.");
ZCREPORT_BYTES(cJSPathPrefix + NS_LITERAL_CSTRING("shapes/malloc-heap/compartment-tables"),
cStats.shapesCompartmentTables,
cStats.shapesMallocHeapCompartmentTables,
"Memory on the malloc heap used by compartment-wide tables storing shape "
"information for use during object construction.");
ZCREPORT_BYTES(cJSPathPrefix + NS_LITERAL_CSTRING("scripts/malloc-heap/data"),
cStats.scriptData,
cStats.scriptsMallocHeapData,
"Memory on the malloc heap allocated for various variable-length tables in "
"JSScript.");
@ -2156,18 +2156,18 @@ ReportCompartmentStats(const JS::CompartmentStats &cStats,
cStats.typeInference.objectTypeTables,
"Memory indexing type objects associated with object literals.");
if (gcHeapSundries > 0) {
if (sundriesGCHeap > 0) {
// We deliberately don't use ZCREPORT_GC_BYTES here.
REPORT_GC_BYTES(cJSPathPrefix + NS_LITERAL_CSTRING("sundries/gc-heap"),
gcHeapSundries,
sundriesGCHeap,
"The sum of all the 'gc-heap' measurements that are too "
"small to be worth showing individually.");
}
if (otherSundries > 0) {
if (sundriesMallocHeap > 0) {
// We deliberately don't use ZCREPORT_BYTES here.
REPORT_BYTES(cJSPathPrefix + NS_LITERAL_CSTRING("sundries/malloc-heap"),
KIND_HEAP, otherSundries,
KIND_HEAP, sundriesMallocHeap,
"The sum of all the 'malloc-heap' measurements that are too "
"small to be worth showing individually.");
}