src: fix timing of snapshot serialize callback

lib/internal/main/mksnapshot.js

@@ -21,7 +21,6 @@ const { emitExperimentalWarning } = require('internal/util');
 const { emitWarningSync } = require('internal/process/warning');
 
 const {
-  initializeCallbacks,
   namespace: {
     addDeserializeCallback,
     isBuildingSnapshot,
@@ -139,7 +138,6 @@ function requireForUserSnapshot(id) {
 
 function main() {
   prepareMainThreadExecution(false, false);
-  initializeCallbacks();
 
   // In a context created for building snapshots, V8 does not install Error.stackTraceLimit and as
   // a result, if an error is created during the snapshot building process, error.stack would be

lib/internal/v8/startup_snapshot.js

@@ -115,8 +115,8 @@ function setDeserializeMainFunction(callback, data) {
   });
 }
 
+initializeCallbacks();
 module.exports = {
-  initializeCallbacks,
   runDeserializeCallbacks,
   throwIfBuildingSnapshot,
   // Exposed to require('v8').startupSnapshot

src/api/environment.cc

@@ -6,6 +6,7 @@
 #include "node.h"
 #include "node_builtins.h"
 #include "node_context_data.h"
+#include "node_debug.h"
 #include "node_errors.h"
 #include "node_exit_code.h"
 #include "node_internals.h"
@@ -112,17 +113,21 @@ MaybeLocal<Value> PrepareStackTraceCallback(Local<Context> context,
 
 void* NodeArrayBufferAllocator::Allocate(size_t size) {
   void* ret;
-  if (zero_fill_field_ || per_process::cli_options->zero_fill_all_buffers)
+  if (zero_fill_field_ || per_process::cli_options->zero_fill_all_buffers) {
+    COUNT_GENERIC_USAGE("NodeArrayBufferAllocator.Allocate.ZeroFilled");
     ret = allocator_->Allocate(size);
-  else
+  } else {
+    COUNT_GENERIC_USAGE("NodeArrayBufferAllocator.Allocate.Uninitialized");
     ret = allocator_->AllocateUninitialized(size);
+  }
   if (ret != nullptr) [[likely]] {
     total_mem_usage_.fetch_add(size, std::memory_order_relaxed);
   }
   return ret;
 }
 
 void* NodeArrayBufferAllocator::AllocateUninitialized(size_t size) {
+  COUNT_GENERIC_USAGE("NodeArrayBufferAllocator.Allocate.Uninitialized");
   void* ret = allocator_->AllocateUninitialized(size);
   if (ret != nullptr) [[likely]] {
     total_mem_usage_.fetch_add(size, std::memory_order_relaxed);

src/node_debug.cc

@@ -8,6 +8,7 @@
 #include "v8-fast-api-calls.h"
 #include "v8.h"
 
+#include <string>
 #include <string_view>
 #include <unordered_map>
 #endif  // DEBUG
@@ -23,9 +24,20 @@ using v8::Number;
 using v8::Object;
 using v8::Value;
 
+thread_local std::unordered_map<std::string, int> generic_usage_counters;
 thread_local std::unordered_map<FastStringKey, int, FastStringKey::Hash>
     v8_fast_api_call_counts;
 
+void CountGenericUsage(const char* counter_name) {
+  if (generic_usage_counters.find(counter_name) == generic_usage_counters.end())
+    generic_usage_counters[counter_name] = 0;
+  generic_usage_counters[counter_name]++;
+}
+
+int GetGenericUsageCount(const char* counter_name) {
+  return generic_usage_counters[counter_name];
+}
+
 void TrackV8FastApiCall(FastStringKey key) {
   v8_fast_api_call_counts[key]++;
 }
@@ -34,6 +46,17 @@ int GetV8FastApiCallCount(FastStringKey key) {
   return v8_fast_api_call_counts[key];
 }
 
+void GetGenericUsageCount(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+  if (!args[0]->IsString()) {
+    env->ThrowError("getGenericUsageCount must be called with a string");
+    return;
+  }
+  Utf8Value utf8_key(env->isolate(), args[0]);
+  args.GetReturnValue().Set(
+      GetGenericUsageCount(utf8_key.ToStringView().data()));
+}
+
 void GetV8FastApiCallCount(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
   if (!args[0]->IsString()) {
@@ -89,6 +112,7 @@ void Initialize(Local<Object> target,
                 Local<Context> context,
                 void* priv) {
   SetMethod(context, target, "getV8FastApiCallCount", GetV8FastApiCallCount);
+  SetMethod(context, target, "getGenericUsageCount", GetGenericUsageCount);
   SetFastMethod(context, target, "isEven", SlowIsEven, &fast_is_even);
   SetFastMethod(context, target, "isOdd", SlowIsOdd, &fast_is_odd);
 }

src/node_debug.h

@@ -13,10 +13,14 @@ namespace debug {
 void TrackV8FastApiCall(FastStringKey key);
 int GetV8FastApiCallCount(FastStringKey key);
 
+void CountGenericUsage(const char* counter_name);
+#define COUNT_GENERIC_USAGE(name) node::debug::CountGenericUsage(name)
+
 #define TRACK_V8_FAST_API_CALL(key)                                            \
   node::debug::TrackV8FastApiCall(FastStringKey(key))
 #else  // !DEBUG
 #define TRACK_V8_FAST_API_CALL(key)
+#define COUNT_GENERIC_USAGE(name)
 #endif  // DEBUG
 
 }  // namespace debug

test/parallel/test-buffer-alloc-unsafe-is-uninitialized.js

@@ -0,0 +1,17 @@
+// Flags: --expose-internals
+// Verifies that Buffer.allocUnsafe() indeed allocates uninitialized memory by checking
+// the usage count of the relevant native allocator code path.
+'use strict';
+
+const common = require('../common');
+if (!common.isDebug) {
+  common.skip('Only works in debug mode');
+}
+const { internalBinding } = require('internal/test/binding');
+const { getGenericUsageCount } = internalBinding('debug');
+const assert = require('assert');
+
+const initialCount = getGenericUsageCount('NodeArrayBufferAllocator.Allocate.Uninitialized');
+Buffer.allocUnsafe(Buffer.poolSize + 1);
+const newCount = getGenericUsageCount('NodeArrayBufferAllocator.Allocate.Uninitialized');
+assert.notStrictEqual(newCount, initialCount);