Reduce memory usage of allocation profiles (#188)

Author: szegedi

binding.gyp

@@ -16,6 +16,7 @@
                             "bindings/profilers/wall.cc",
                             "bindings/per-isolate-data.cc",
                             "bindings/thread-cpu-clock.cc",
+                            "bindings/translate-heap-profile.cc",
                             "bindings/translate-time-profile.cc",
                             "bindings/binding.cc"
                         ],
@@ -38,6 +39,7 @@
                             "bindings/profilers/wall.cc",
                             "bindings/per-isolate-data.cc",
                             "bindings/thread-cpu-clock.cc",
+                            "bindings/translate-heap-profile.cc",
                             "bindings/translate-time-profile.cc",
                             "bindings/test/binding.cc",
                         ],

bindings/contexts.hh

@@ -16,7 +16,6 @@
 
 #pragma once
 
-#include <nan.h>
 #include <v8-profiler.h>
 #include <unordered_map>
 

bindings/profile-translator.hh

@@ -0,0 +1,67 @@
+/*
+ * Copyright 2024 Datadog, Inc
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <v8.h>
+
+namespace dd {
+class ProfileTranslator {
+  v8::Isolate* isolate = v8::Isolate::GetCurrent();
+  v8::Local<v8::Context> context = isolate->GetCurrentContext();
+  v8::Local<v8::Array> emptyArray = v8::Array::New(isolate, 0);
+
+ protected:
+  v8::Local<v8::Object> NewObject() { return v8::Object::New(isolate); }
+
+  v8::Local<v8::Integer> NewInteger(int x) {
+    return v8::Integer::New(isolate, x);
+  }
+
+  v8::Local<v8::Boolean> NewBoolean(bool x) {
+    return v8::Boolean::New(isolate, x);
+  }
+
+  template <typename T>
+  v8::Local<v8::Number> NewNumber(T x) {
+    return v8::Number::New(isolate, x);
+  }
+
+  v8::Local<v8::Array> NewArray(int length) {
+    return length == 0 ? emptyArray : v8::Array::New(isolate, length);
+  }
+
+  v8::Local<v8::String> NewString(const char* str) {
+    return v8::String::NewFromUtf8(isolate, str).ToLocalChecked();
+  }
+
+  v8::MaybeLocal<v8::Value> Get(v8::Local<v8::Array> arr, uint32_t index) {
+    return arr->Get(context, index);
+  }
+
+  v8::Maybe<bool> Set(v8::Local<v8::Array> arr,
+                      uint32_t index,
+                      v8::Local<v8::Value> value) {
+    return arr->Set(context, index, value);
+  }
+
+  v8::Maybe<bool> Set(v8::Local<v8::Object> obj,
+                      v8::Local<v8::Value> key,
+                      v8::Local<v8::Value> value) {
+    return obj->Set(context, key, value);
+  }
+
+  ProfileTranslator() = default;
+};
+};  // namespace dd

bindings/profilers/heap.cc

@@ -18,6 +18,7 @@
 
 #include "defer.hh"
 #include "per-isolate-data.hh"
+#include "translate-heap-profile.hh"
 
 #include <chrono>
 #include <memory>
@@ -482,49 +483,6 @@ size_t NearHeapLimit(void* data,
   return new_heap_limit;
 }
 
-v8::Local<v8::Value> TranslateAllocationProfile(
-    v8::AllocationProfile::Node* node) {
-  v8::Local<v8::Object> js_node = Nan::New<v8::Object>();
-
-  Nan::Set(js_node, Nan::New<v8::String>("name").ToLocalChecked(), node->name);
-  Nan::Set(js_node,
-           Nan::New<v8::String>("scriptName").ToLocalChecked(),
-           node->script_name);
-  Nan::Set(js_node,
-           Nan::New<v8::String>("scriptId").ToLocalChecked(),
-           Nan::New<v8::Integer>(node->script_id));
-  Nan::Set(js_node,
-           Nan::New<v8::String>("lineNumber").ToLocalChecked(),
-           Nan::New<v8::Integer>(node->line_number));
-  Nan::Set(js_node,
-           Nan::New<v8::String>("columnNumber").ToLocalChecked(),
-           Nan::New<v8::Integer>(node->column_number));
-
-  v8::Local<v8::Array> children = Nan::New<v8::Array>(node->children.size());
-  for (size_t i = 0; i < node->children.size(); i++) {
-    Nan::Set(children, i, TranslateAllocationProfile(node->children[i]));
-  }
-  Nan::Set(
-      js_node, Nan::New<v8::String>("children").ToLocalChecked(), children);
-  v8::Local<v8::Array> allocations =
-      Nan::New<v8::Array>(node->allocations.size());
-  for (size_t i = 0; i < node->allocations.size(); i++) {
-    v8::AllocationProfile::Allocation alloc = node->allocations[i];
-    v8::Local<v8::Object> js_alloc = Nan::New<v8::Object>();
-    Nan::Set(js_alloc,
-             Nan::New<v8::String>("sizeBytes").ToLocalChecked(),
-             Nan::New<v8::Number>(alloc.size));
-    Nan::Set(js_alloc,
-             Nan::New<v8::String>("count").ToLocalChecked(),
-             Nan::New<v8::Number>(alloc.count));
-    Nan::Set(allocations, i, js_alloc);
-  }
-  Nan::Set(js_node,
-           Nan::New<v8::String>("allocations").ToLocalChecked(),
-           allocations);
-  return js_node;
-}
-
 NAN_METHOD(HeapProfiler::StartSamplingHeapProfiler) {
   if (info.Length() == 2) {
     if (!info[0]->IsUint32()) {

bindings/translate-heap-profile.cc

@@ -0,0 +1,103 @@
+/*
+ * Copyright 2024 Datadog, Inc
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "translate-heap-profile.hh"
+#include "profile-translator.hh"
+
+namespace dd {
+
+namespace {
+class HeapProfileTranslator : ProfileTranslator {
+#define NODE_FIELDS                                                            \
+  X(name)                                                                      \
+  X(scriptName)                                                                \
+  X(scriptId)                                                                  \
+  X(lineNumber)                                                                \
+  X(columnNumber)                                                              \
+  X(children)                                                                  \
+  X(allocations)
+
+#define ALLOCATION_FIELDS                                                      \
+  X(sizeBytes)                                                                 \
+  X(count)
+
+#define X(name) v8::Local<v8::String> str_##name = NewString(#name);
+  NODE_FIELDS
+  ALLOCATION_FIELDS
+#undef X
+
+ public:
+  v8::Local<v8::Value> TranslateAllocationProfile(
+      v8::AllocationProfile::Node* node) {
+    v8::Local<v8::Array> children = NewArray(node->children.size());
+    for (size_t i = 0; i < node->children.size(); i++) {
+      Set(children, i, TranslateAllocationProfile(node->children[i]));
+    }
+
+    v8::Local<v8::Array> allocations = NewArray(node->allocations.size());
+    for (size_t i = 0; i < node->allocations.size(); i++) {
+      auto alloc = node->allocations[i];
+      Set(allocations,
+          i,
+          CreateAllocation(NewNumber(alloc.size), NewNumber(alloc.count)));
+    }
+
+    return CreateNode(node->name,
+                      node->script_name,
+                      NewInteger(node->script_id),
+                      NewInteger(node->line_number),
+                      NewInteger(node->column_number),
+                      children,
+                      allocations);
+  }
+
+ private:
+  v8::Local<v8::Object> CreateNode(v8::Local<v8::String> name,
+                                   v8::Local<v8::String> scriptName,
+                                   v8::Local<v8::Integer> scriptId,
+                                   v8::Local<v8::Integer> lineNumber,
+                                   v8::Local<v8::Integer> columnNumber,
+                                   v8::Local<v8::Array> children,
+                                   v8::Local<v8::Array> allocations) {
+    v8::Local<v8::Object> js_node = NewObject();
+#define X(name) Set(js_node, str_##name, name);
+    NODE_FIELDS
+#undef X
+#undef NODE_FIELDS
+    return js_node;
+  }
+
+  v8::Local<v8::Object> CreateAllocation(v8::Local<v8::Number> count,
+                                         v8::Local<v8::Number> sizeBytes) {
+    v8::Local<v8::Object> js_alloc = NewObject();
+#define X(name) Set(js_alloc, str_##name, name);
+    ALLOCATION_FIELDS
+#undef X
+#undef ALLOCATION_FIELDS
+    return js_alloc;
+  }
+
+ public:
+  explicit HeapProfileTranslator() {}
+};
+}  // namespace
+
+v8::Local<v8::Value> TranslateAllocationProfile(
+    v8::AllocationProfile::Node* node) {
+  return HeapProfileTranslator().TranslateAllocationProfile(node);
+}
+
+}  // namespace dd

bindings/translate-heap-profile.hh

@@ -0,0 +1,26 @@
+/*
+ * Copyright 2024 Datadog, Inc
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <v8-profiler.h>
+
+namespace dd {
+
+v8::Local<v8::Value> TranslateAllocationProfile(
+    v8::AllocationProfile::Node* node);
+
+}  // namespace dd