Implement heap snapsnot memory tracking for Event, EventTarget

cloudflare · Feb 5, 2024 · 8691915 · 8691915
1 parent 6283473
commit 8691915
Show file tree

Hide file tree

Showing 7 changed files with 152 additions and 61 deletions.
diff --git a/src/workerd/api/basics.c++ b/src/workerd/api/basics.c++
@@ -768,4 +768,45 @@ CustomEvent::CustomEventInit::operator Event::Init() {
   };
 }
 
+size_t EventTarget::EventHandler::JavaScriptHandler::jsgGetMemorySelfSize() const {
+  return sizeof(JavaScriptHandler);
+}
+
+void EventTarget::EventHandler::JavaScriptHandler::jsgGetMemoryInfo(
+    jsg::MemoryTracker& tracker) const {
+  tracker.trackField("identity", identity);
+  tracker.trackField("callback", callback);
+  if (abortHandler != kj::none) {
+    tracker.trackFieldWithSize("abortHandler", sizeof(kj::Own<NativeHandler>) +
+                                                sizeof(NativeHandler));
+  }
+}
+
+size_t EventTarget::EventHandler::jsgGetMemorySelfSize() const {
+  return sizeof(EventHandler);
+}
+
+void EventTarget::EventHandler::jsgGetMemoryInfo(jsg::MemoryTracker& tracker) const {
+  KJ_SWITCH_ONEOF(handler) {
+    KJ_CASE_ONEOF(js, JavaScriptHandler) {
+      tracker.trackField("js", js);
+    }
+    KJ_CASE_ONEOF(native, NativeHandlerRef) {
+      tracker.trackFieldWithSize("native", sizeof(NativeHandlerRef));
+    }
+  }
+}
+
+size_t EventTarget::EventHandlerSet::jsgGetMemorySelfSize() const {
+  return sizeof(EventHandlerSet);
+}
+
+void EventTarget::EventHandlerSet::jsgGetMemoryInfo(jsg::MemoryTracker& tracker) const {
+  tracker.trackField("handlers", handlers, kj::none, kj::none, false);
+}
+
+void EventTarget::visitForMemoryInfo(jsg::MemoryTracker& tracker) const {
+  tracker.trackField("typeMap", typeMap);
+}
+
 }  // namespace workerd::api
diff --git a/src/workerd/api/basics.h b/src/workerd/api/basics.h
@@ -148,6 +148,11 @@ class Event: public jsg::Object {
     JSG_STATIC_CONSTANT(BUBBLING_PHASE);
   }
 
+  void visitForMemoryInfo(jsg::MemoryTracker& tracker) const {
+    tracker.trackField("type", ownType);
+    tracker.trackField("target", target);
+  }
+
 private:
   kj::StringPtr type;
   kj::String ownType;
@@ -215,6 +220,10 @@ class CustomEvent: public Event {
     JSG_READONLY_PROTOTYPE_PROPERTY(detail, getDetail);
   }
 
+  void visitForMemoryInfo(jsg::MemoryTracker& tracker) const {
+    tracker.trackField("detail", detail);
+  }
+
 private:
   jsg::Optional<jsg::JsRef<jsg::JsValue>> detail;
 };
@@ -308,6 +317,8 @@ class EventTarget: public jsg::Object {
       jsg::Function<void(jsg::Ref<Event>)> func,
       bool once = false);
 
+  void visitForMemoryInfo(jsg::MemoryTracker& tracker) const;
+
 private:
   void addNativeListener(jsg::Lock& js, NativeHandler& handler);
   bool removeNativeListener(NativeHandler& handler);
@@ -323,6 +334,10 @@ class EventTarget: public jsg::Object {
       void visitForGc(jsg::GcVisitor& visitor) {
         visitor.visit(identity, callback);
       }
+
+      kj::StringPtr jsgGetMemoryName() const { return "JavaScriptHandler"_kjc; }
+      size_t jsgGetMemorySelfSize() const;
+      void jsgGetMemoryInfo(jsg::MemoryTracker& tracker) const;
     };
 
     struct NativeHandlerRef {
@@ -338,6 +353,10 @@ class EventTarget: public jsg::Object {
 
     // When once is true, the handler will be removed after it is invoked one time.
     bool once = false;
+
+    kj::StringPtr jsgGetMemoryName() const { return "EventHandler"_kjc; }
+    size_t jsgGetMemorySelfSize() const;
+    void jsgGetMemoryInfo(jsg::MemoryTracker& tracker) const;
   };
 
   struct EventHandlerHashCallbacks {
@@ -360,6 +379,10 @@ class EventTarget: public jsg::Object {
 
     EventHandlerSet()
         : handlers(EventHandlerHashCallbacks(), {}) {}
+
+    kj::StringPtr jsgGetMemoryName() const { return "EventHandlerSet"_kjc; }
+    size_t jsgGetMemorySelfSize() const;
+    void jsgGetMemoryInfo(jsg::MemoryTracker& tracker) const;
   };
 
   EventHandlerSet& getOrCreate(kj::StringPtr str) KJ_LIFETIMEBOUND;
@@ -463,6 +486,13 @@ class AbortSignal final: public EventTarget {
 
   RefcountedCanceler& getCanceler();
 
+  void visitForMemoryInfo(jsg::MemoryTracker& tracker) const {
+    EventTarget::visitForMemoryInfo(tracker);
+    tracker.trackInlineFieldWithSize("IoOwn<RefcountedCanceler>",
+        sizeof(IoOwn<RefcountedCanceler>));
+    tracker.trackField("reason", reason);
+  }
+
 private:
   IoOwn<RefcountedCanceler> canceler;
   Flag flag;
@@ -496,6 +526,10 @@ class AbortController final: public jsg::Object {
     JSG_METHOD(abort);
   }
 
+  void visitForMemoryInfo(jsg::MemoryTracker& tracker) const {
+    tracker.trackField("signal", signal);
+  }
+
 private:
   jsg::Ref<AbortSignal> signal;
 

diff --git a/src/workerd/api/global-scope.h b/src/workerd/api/global-scope.h
@@ -122,6 +122,11 @@ class PromiseRejectionEvent: public Event {
     JSG_READONLY_INSTANCE_PROPERTY(reason, getReason);
   }
 
+  void visitForMemoryInfo(jsg::MemoryTracker& tracker) const {
+    tracker.trackField("promise", promise);
+    tracker.trackField("reason", reason);
+  }
+
 private:
   jsg::V8Ref<v8::Promise> promise;
   jsg::Value reason;
@@ -656,6 +661,10 @@ class ServiceWorkerGlobalScope: public WorkerGlobalScope {
   TimeoutId::Generator timeoutIdGenerator;
   // The generator for all timeout IDs associated with this scope.
 
+  void visitForMemoryInfo(jsg::MemoryTracker& tracker) const {
+    tracker.trackField("unhandledRejections", unhandledRejections);
+  }
+
 private:
   jsg::UnhandledRejectionHandler unhandledRejections;
 

diff --git a/src/workerd/api/gpu/gpu-device.h b/src/workerd/api/gpu/gpu-device.h
@@ -120,6 +120,10 @@ class GPUUncapturedErrorEvent : public Event {
     JSG_READONLY_INSTANCE_PROPERTY(error, getError);
   }
 
+  void visitForMemoryInfo(jsg::MemoryTracker& tracker) const {
+    tracker.trackField("error", error_);
+  }
+
 private:
   jsg::Ref<GPUError> error_;
 

diff --git a/src/workerd/api/web-socket.h b/src/workerd/api/web-socket.h
@@ -67,6 +67,10 @@ class MessageEvent: public Event {
     });
   }
 
+  void visitForMemoryInfo(jsg::MemoryTracker& tracker) const {
+    tracker.trackField("data", data);
+  }
+
 private:
   jsg::JsRef<jsg::JsValue> data;
 
@@ -112,6 +116,10 @@ class CloseEvent: public Event {
     // CloseEvent will be referenced from the `WebSocketEventMap` define
   }
 
+  void visitForMemoryInfo(jsg::MemoryTracker& tracker) const {
+    tracker.trackField("reason", reason);
+  }
+
 private:
   int code;
   kj::String reason;
@@ -147,6 +155,11 @@ class ErrorEvent: public Event {
     // ErrorEvent will be referenced from the `WebSocketEventMap` define
   }
 
+  void visitForMemoryInfo(jsg::MemoryTracker& tracker) const {
+    tracker.trackField("message", message);
+    tracker.trackField("error", error);
+  }
+
 private:
   kj::String message;
   jsg::JsRef<jsg::JsValue> error;

diff --git a/src/workerd/jsg/iterator.h b/src/workerd/jsg/iterator.h
@@ -813,7 +813,7 @@ class AsyncIteratorBase: public Object {
       if constexpr (MemoryRetainer<State>) {
         tracker.trackField("state", state);
       } else {
-        tracker.trackField("state", sizeof(State));
+        tracker.trackFieldWithSize("state", sizeof(State));
       }
       tracker.trackField("impl", impl);
     }