Implement MemoryTracker for Heap Snapshots

[jasnell]

This is adapted from Node.js' implementation.

This extends workerd's v8::HeapSnapshot collection process to allow including more detailed information about internal/native objects. Best illustrated with a screenshot...

This PR includes the core part of the implementation. It provides a straightforward implementation of jsg::Objects / jsg::Wrappable snapshot tracing along with a handful of other types. It does *NOT add all of the instrumentation to all of the various objects.

Those familiar with the GC tracing mechanism should find this familiar.

Look at the memory-test.c++ for an example of how it's used.

To keep things as simple as possible, to instrument your typical jsg::Object type (anything using JSG_RESOURCE_TYPE, you only need to provide an implementation of the visitForMemoryInfo(...) method:

struct Foo: public Object {
  kj::String bar = kj::str("test");

  JSG_RESOURCE_TYPE(Foo) {}
  
void visitForMemoryInfo(MemoryTracker& tracker) const {
    tracker.trackField("bar", bar);
  }
};

This should be familiar to anyone who has implemented support for GC tracing (using the visitForGc(...) method).

Any fields you want to include in the heap snapshot are registered using trackField(...) or trackFieldWithSize(...).

If you want anything else to be trackable, then it will need to implement all three of the following methods:

kj::StringPtr getMemoryInfoName() const { return "TheName"_kjc; }
size_t getMemoryInfoSelfSize() const { return sizeof(ThisThing); }
void getMemoryInfo(MemoryTracker& tracker) const {
   // register the fields here
}

To check to see if a type if trackable, you can test it using something like:

static constexpr bool IS_TESTABLE = MemoryRetainer<T>;

From the typical day-to-day use there wouldn't be much more than that. There a few more advanced cases to consider and we might want to expand the trackField(...) implementations in memory.h to add support for various types, but for the most part this was designed to be as minimally intrusive as possible.

[dom96]

This is super cool!

One concern: what overhead does this add? Is it something that we disable by default so it shouldn't affect our performance upstream?

[jasnell]

One concern: what overhead does this add? Is it something that we disable by default so it shouldn't affect our performance upstream?

This code is only engaged when a heap snapshot is taken so the overhead will be minimal.