Report memory size of performance.measure / performance.mark (#16094)

Author: Jarred-Sumner

src/bun.js/bindings/JSDOMExceptionHandling.cpp

@@ -164,6 +164,7 @@ JSValue createDOMException(JSGlobalObject* lexicalGlobalObject, ExceptionCode ec
             return createRangeError(lexicalGlobalObject, "Bad value"_s);
         return createRangeError(lexicalGlobalObject, message);
 
+    case ExceptionCode::SyntaxError:
     case ExceptionCode::JSSyntaxError:
         if (message.isEmpty())
             return createSyntaxError(lexicalGlobalObject);

src/bun.js/bindings/webcore/JSPerformance.cpp

@@ -255,6 +255,12 @@ JSPerformance::JSPerformance(Structure* structure, JSDOMGlobalObject& globalObje
 {
 }
 
+size_t JSPerformance::estimatedSize(JSCell* cell, VM& vm)
+{
+    JSPerformance* thisObject = jsCast<JSPerformance*>(cell);
+    return Base::estimatedSize(cell, vm) + thisObject->wrapped().memoryCost();
+}
+
 // static_assert(!std::is_base_of<ActiveDOMObject, Performance>::value, "Interface is not marked as [ActiveDOMObject] even though implementation class subclasses ActiveDOMObject.");
 
 void JSPerformance::finishCreation(VM& vm)

src/bun.js/bindings/webcore/JSPerformance.h

@@ -60,6 +60,7 @@ class JSPerformance : public JSEventTarget {
     }
     static JSC::GCClient::IsoSubspace* subspaceForImpl(JSC::VM& vm);
     static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
+    static size_t estimatedSize(JSC::JSCell* cell, JSC::VM& vm);
     Performance& wrapped() const
     {
         return static_cast<Performance&>(Base::wrapped());

src/bun.js/bindings/webcore/Performance.cpp

@@ -189,6 +189,16 @@ Vector<RefPtr<PerformanceEntry>> Performance::getEntriesByType(const String& ent
     return entries;
 }
 
+size_t Performance::memoryCost() const
+{
+    size_t size = sizeof(Performance);
+    size += m_resourceTimingBuffer.size() * sizeof(PerformanceResourceTiming);
+    if (m_userTiming) {
+        size += m_userTiming->memoryCost();
+    }
+    return size;
+}
+
 Vector<RefPtr<PerformanceEntry>> Performance::getEntriesByName(const String& name, const String& entryType) const
 {
     Vector<RefPtr<PerformanceEntry>> entries;

src/bun.js/bindings/webcore/Performance.h

@@ -111,6 +111,8 @@ class Performance final : public RefCounted<Performance>, public ContextDestruct
 
     // void reportFirstContentfulPaint();
 
+    size_t memoryCost() const;
+
     void removeAllObservers();
     void registerPerformanceObserver(PerformanceObserver&);
     void unregisterPerformanceObserver(PerformanceObserver&);

src/bun.js/bindings/webcore/PerformanceEntry.cpp

@@ -31,6 +31,10 @@
 #include "config.h"
 #include "PerformanceEntry.h"
 
+#include "PerformanceMark.h"
+#include "PerformanceMeasure.h"
+#include "PerformanceResourceTiming.h"
+
 // #include "DeprecatedGlobalSettings.h"
 
 namespace WebCore {
@@ -46,6 +50,28 @@ PerformanceEntry::PerformanceEntry(const String& name, double startTime, double
 
 PerformanceEntry::~PerformanceEntry() = default;
 
+size_t PerformanceEntry::memoryCost() const
+{
+    size_t baseCost = this->m_name.sizeInBytes();
+    switch (performanceEntryType()) {
+    case Type::Mark: {
+        const PerformanceMark* mark = static_cast<const PerformanceMark*>(this);
+        return mark->memoryCost() + baseCost;
+    }
+    case Type::Measure: {
+        const PerformanceMeasure* measure = static_cast<const PerformanceMeasure*>(this);
+        return measure->memoryCost() + baseCost;
+    }
+    case Type::Resource: {
+        const PerformanceResourceTiming* resource = static_cast<const PerformanceResourceTiming*>(this);
+        return resource->memoryCost() + baseCost;
+    }
+    default: {
+        return sizeof(PerformanceEntry) + baseCost;
+    }
+    }
+}
+
 std::optional<PerformanceEntry::Type> PerformanceEntry::parseEntryTypeString(const String& entryType)
 {
     if (entryType == "navigation"_s)

src/bun.js/bindings/webcore/PerformanceEntry.h

@@ -59,6 +59,8 @@ class PerformanceEntry : public RefCounted<PerformanceEntry> {
     virtual Type performanceEntryType() const = 0;
     virtual ASCIILiteral entryType() const = 0;
 
+    size_t memoryCost() const;
+
     static std::optional<Type> parseEntryTypeString(const String& entryType);
 
     static bool startTimeCompareLessThan(const RefPtr<PerformanceEntry>& a, const RefPtr<PerformanceEntry>& b)

src/bun.js/bindings/webcore/PerformanceMark.cpp

@@ -85,6 +85,15 @@ PerformanceMark::PerformanceMark(const String& name, double startTime, RefPtr<Se
 
 PerformanceMark::~PerformanceMark() = default;
 
+size_t PerformanceMark::memoryCost() const
+{
+    size_t size = sizeof(PerformanceMark);
+    if (m_serializedDetail) {
+        size += m_serializedDetail->memoryCost();
+    }
+    return size;
+}
+
 JSC::JSValue PerformanceMark::detail(JSC::JSGlobalObject& globalObject)
 {
     if (!m_serializedDetail) {

src/bun.js/bindings/webcore/PerformanceMark.h

@@ -44,6 +44,8 @@ class PerformanceMark final : public PerformanceEntry {
 
     JSC::JSValue detail(JSC::JSGlobalObject&);
 
+    size_t memoryCost() const;
+
 private:
     PerformanceMark(const String& name, double startTime, RefPtr<SerializedScriptValue>&&);
     ~PerformanceMark();

src/bun.js/bindings/webcore/PerformanceMeasure.cpp

@@ -30,6 +30,15 @@
 
 namespace WebCore {
 
+size_t PerformanceMeasure::memoryCost() const
+{
+    size_t size = sizeof(PerformanceMeasure);
+    if (m_serializedDetail) {
+        size += m_serializedDetail->memoryCost();
+    }
+    return size;
+}
+
 ExceptionOr<Ref<PerformanceMeasure>> PerformanceMeasure::create(const String& name, double startTime, double endTime, RefPtr<SerializedScriptValue>&& serializedDetail)
 {
     return adoptRef(*new PerformanceMeasure(name, startTime, endTime, WTFMove(serializedDetail)));