process: support hrtime in the snapshot

Put the hrtime backing store in the process methods binding data
so that it can be integrated into the snapshot builder. For
now we simply discard the contents of the hrtime buffer during
serialization and create new buffers upon deserialization because
the contents are only useful in a synchronous call.
This also moves the helper function for creating V8 FastAPI methods
into `Environment::SetFastMethod()` for code reuse. The v8::CFunction
need to be created before the Environment is created so that we
have the CTypeInfo address available for external reference
registration.
PR-URL: #40649
Refs: #35711
Refs: #37476
Reviewed-By: James M Snell <jasnell@gmail.com>

Author: joyeecheung

lib/internal/bootstrap/node.js

@@ -162,6 +162,9 @@ const rawMethods = internalBinding('process_methods');
 process.kill=wrapped.kill;
 process.exit=wrapped.exit;
 
+process.hrtime=perThreadSetup.hrtime;
+process.hrtime.bigint=perThreadSetup.hrtimeBigInt;
+
 process.openStdin=function(){
 process.stdin.resume();
 returnprocess.stdin;

lib/internal/bootstrap/pre_execution.js

@@ -82,16 +82,7 @@ function patchProcessObject(expandArgv1) {
 constbinding=internalBinding('process_methods');
 binding.patchProcessObject(process);
 
-// TODO(joyeecheung): snapshot fast APIs (which need to work with
-// array buffers, whose connection with C++ needs to be rebuilt after
-// deserialization).
-const{
- hrtime,
- hrtimeBigInt
-}=require('internal/process/per_thread').getFastAPIs(binding);
-
-process.hrtime=hrtime;
-process.hrtime.bigint=hrtimeBigInt;
+require('internal/process/per_thread').refreshHrtimeBuffer();
 
 ObjectDefineProperty(process,'argv0',{
 enumerable: true,

lib/internal/process/per_thread.js

@@ -54,49 +54,48 @@ function assert(x, msg) {
 if(!x)thrownewERR_ASSERTION(msg||'assertion error');
 }
 
-functiongetFastAPIs(binding){
-const{
-hrtime: _hrtime
-}=binding.getFastAPIs();
+constbinding=internalBinding('process_methods');
+
+lethrValues;
+lethrBigintValues;
 
+functionrefreshHrtimeBuffer(){
 // The 3 entries filled in by the original process.hrtime contains
 // the upper/lower 32 bits of the second part of the value,
 // and the remaining nanoseconds of the value.
-consthrValues=newUint32Array(_hrtime.buffer);
+hrValues=newUint32Array(binding.hrtimeBuffer);
+// Use a BigUint64Array in the closure because this is actually a bit
+// faster than simply returning a BigInt from C++ in V8 7.1.
+hrBigintValues=newBigUint64Array(binding.hrtimeBuffer,0,1);
+}
 
-functionhrtime(time){
-_hrtime.hrtime();
+// Create the buffers.
+refreshHrtimeBuffer();
 
-if(time!==undefined){
-validateArray(time,'time');
-if(time.length!==2){
-thrownewERR_OUT_OF_RANGE('time',2,time.length);
-}
+functionhrtime(time){
+binding.hrtime();
 
-constsec=(hrValues[0]*0x100000000+hrValues[1])-time[0];
-constnsec=hrValues[2]-time[1];
-constneedsBorrow=nsec<0;
-return[needsBorrow ? sec-1 : sec,needsBorrow ? nsec+1e9 : nsec];
+if(time!==undefined){
+validateArray(time,'time');
+if(time.length!==2){
+thrownewERR_OUT_OF_RANGE('time',2,time.length);
 }
 
-return[
-hrValues[0]*0x100000000+hrValues[1],
-hrValues[2],
-];
+constsec=(hrValues[0]*0x100000000+hrValues[1])-time[0];
+constnsec=hrValues[2]-time[1];
+constneedsBorrow=nsec<0;
+return[needsBorrow ? sec-1 : sec,needsBorrow ? nsec+1e9 : nsec];
 }
 
-// Use a BigUint64Array in the closure because this is actually a bit
-// faster than simply returning a BigInt from C++ in V8 7.1.
-consthrBigintValues=newBigUint64Array(_hrtime.buffer,0,1);
-functionhrtimeBigInt(){
-_hrtime.hrtimeBigInt();
-returnhrBigintValues[0];
-}
+return[
+hrValues[0]*0x100000000+hrValues[1],
+hrValues[2],
+];
+}
 
-return{
- hrtime,
- hrtimeBigInt,
-};
+functionhrtimeBigInt(){
+binding.hrtimeBigInt();
+returnhrBigintValues[0];
 }
 
 // The execution of this function itself should not cause any side effects.
@@ -396,8 +395,10 @@ function toggleTraceCategoryState(asyncHooksEnabled) {
 
 module.exports={
  toggleTraceCategoryState,
- getFastAPIs,
  assert,
  buildAllowedFlags,
- wrapProcessMethods
+ wrapProcessMethods,
+ hrtime,
+ hrtimeBigInt,
+ refreshHrtimeBuffer,
 };

src/env-inl.h

@@ -29,11 +29,12 @@
 #include"callback_queue-inl.h"
 #include"env.h"
 #include"node.h"
+#include"node_context_data.h"
+#include"node_perf_common.h"
 #include"util-inl.h"
 #include"uv.h"
+#include"v8-fast-api-calls.h"
 #include"v8.h"
-#include"node_perf_common.h"
-#include"node_context_data.h"
 
 #include<cstddef>
 #include<cstdint>
@@ -1036,13 +1037,20 @@ inline void Environment::ThrowUVException(int errorno,
 UVException(isolate(), errorno, syscall, message, path, dest));
 }
 
-inline v8::Local<v8::FunctionTemplate>
-Environment::NewFunctionTemplate(v8::FunctionCallback callback,
- v8::Local<v8::Signature> signature,
- v8::ConstructorBehavior behavior,
- v8::SideEffectType side_effect_type) {
-returnv8::FunctionTemplate::New(isolate(), callback, v8::Local<v8::Value>(),
- signature, 0, behavior, side_effect_type);
+inline v8::Local<v8::FunctionTemplate> Environment::NewFunctionTemplate(
+ v8::FunctionCallback callback,
+ v8::Local<v8::Signature> signature,
+ v8::ConstructorBehavior behavior,
+ v8::SideEffectType side_effect_type,
+const v8::CFunction* c_function) {
+returnv8::FunctionTemplate::New(isolate(),
+ callback,
+ v8::Local<v8::Value>(),
+ signature,
+0,
+ behavior,
+ side_effect_type,
+ c_function);
 }
 
 inlinevoidEnvironment::SetMethod(v8::Local<v8::Object> that,
@@ -1063,6 +1071,25 @@ inline void Environment::SetMethod(v8::Local<v8::Object> that,
  function->SetName(name_string); // NODE_SET_METHOD() compatibility.
 }
 
+inlinevoidEnvironment::SetFastMethod(v8::Local<v8::Object> that,
+constchar* name,
+ v8::FunctionCallback slow_callback,
+const v8::CFunction* c_function) {
+ v8::Local<v8::Context> context = isolate()->GetCurrentContext();
+ v8::Local<v8::Function> function =
+NewFunctionTemplate(slow_callback,
+ v8::Local<v8::Signature>(),
+ v8::ConstructorBehavior::kThrow,
+ v8::SideEffectType::kHasNoSideEffect,
+ c_function)
+ ->GetFunction(context)
+ .ToLocalChecked();
+const v8::NewStringType type = v8::NewStringType::kInternalized;
+ v8::Local<v8::String> name_string =
+v8::String::NewFromUtf8(isolate(), name, type).ToLocalChecked();
+ that->Set(context, name_string, function).Check();
+}
+
 inlinevoidEnvironment::SetMethodNoSideEffect(v8::Local<v8::Object> that,
 constchar* name,
  v8::FunctionCallback callback) {

src/env.h

@@ -34,6 +34,7 @@
 #include"handle_wrap.h"
 #include"node.h"
 #include"node_binding.h"
+#include"node_external_reference.h"
 #include"node_main_instance.h"
 #include"node_options.h"
 #include"node_perf_common.h"
@@ -1239,20 +1240,23 @@ class Environment : public MemoryRetainer {
 constchar* path = nullptr,
 constchar* dest = nullptr);
 
-inline v8::Local<v8::FunctionTemplate>
-NewFunctionTemplate(v8::FunctionCallback callback,
- v8::Local<v8::Signature> signature =
- v8::Local<v8::Signature>(),
- v8::ConstructorBehavior behavior =
- v8::ConstructorBehavior::kAllow,
- v8::SideEffectType side_effect =
- v8::SideEffectType::kHasSideEffect);
+inline v8::Local<v8::FunctionTemplate> NewFunctionTemplate(
+ v8::FunctionCallback callback,
+ v8::Local<v8::Signature> signature = v8::Local<v8::Signature>(),
+ v8::ConstructorBehavior behavior = v8::ConstructorBehavior::kAllow,
+ v8::SideEffectType side_effect = v8::SideEffectType::kHasSideEffect,
+const v8::CFunction* c_function = nullptr);
 
 // Convenience methods for NewFunctionTemplate().
 inlinevoidSetMethod(v8::Local<v8::Object> that,
 constchar* name,
  v8::FunctionCallback callback);
 
+inlinevoidSetFastMethod(v8::Local<v8::Object> that,
+constchar* name,
+ v8::FunctionCallback slow_callback,
+const v8::CFunction* c_function);
+
 inlinevoidSetProtoMethod(v8::Local<v8::FunctionTemplate> that,
 constchar* name,
  v8::FunctionCallback callback);

src/node_external_reference.h

@@ -5,17 +5,22 @@
 
 #include<cinttypes>
 #include<vector>
+#include"v8-fast-api-calls.h"
 #include"v8.h"
 
 namespacenode {
 
+using CFunctionCallback = void (*)(v8::Local<v8::Value> receiver);
+
 // This class manages the external references from the V8 heap
 // to the C++ addresses in Node.js.
 classExternalReferenceRegistry {
 public:
 ExternalReferenceRegistry();
 
 #defineALLOWED_EXTERNAL_REFERENCE_TYPES(V) \
+V(CFunctionCallback) \
+V(const v8::CFunctionInfo*) \
 V(v8::FunctionCallback) \
 V(v8::AccessorGetterCallback) \
 V(v8::AccessorSetterCallback) \

src/node_process.h

@@ -3,10 +3,16 @@
 
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
+#include"node_snapshotable.h"
+#include"v8-fast-api-calls.h"
 #include"v8.h"
 
 namespacenode {
 
+classEnvironment;
+classMemoryTracker;
+classExternalReferenceRegistry;
+
 v8::MaybeLocal<v8::Object> CreateEnvVarProxy(v8::Local<v8::Context> context,
  v8::Isolate* isolate);
 
@@ -38,6 +44,54 @@ v8::Maybe<bool> ProcessEmitDeprecationWarning(Environment* env,
 v8::MaybeLocal<v8::Object> CreateProcessObject(Environment* env);
 voidPatchProcessObject(const v8::FunctionCallbackInfo<v8::Value>& args);
 
+namespaceprocess {
+classBindingData : publicSnapshotableObject {
+public:
+voidAddMethods();
+staticvoidRegisterExternalReferences(ExternalReferenceRegistry* registry);
+
+SERIALIZABLE_OBJECT_METHODS()
+staticconstexpr FastStringKey type_name{"node::process::BindingData"};
+staticconstexpr EmbedderObjectType type_int =
+ EmbedderObjectType::k_process_binding_data;
+
+BindingData(Environment* env, v8::Local<v8::Object> object);
+
+voidMemoryInfo(MemoryTracker* tracker) constoverride;
+SET_MEMORY_INFO_NAME(BindingData)
+SET_SELF_SIZE(BindingData)
+
+static BindingData* FromV8Value(v8::Local<v8::Value> receiver);
+staticvoidNumberImpl(BindingData* receiver);
+
+staticvoidFastNumber(v8::Local<v8::Value> receiver) {
+NumberImpl(FromV8Value(receiver));
+ }
+
+staticvoidSlowNumber(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+staticvoidBigIntImpl(BindingData* receiver);
+
+staticvoidFastBigInt(v8::Local<v8::Value> receiver) {
+BigIntImpl(FromV8Value(receiver));
+ }
+
+staticvoidSlowBigInt(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+private:
+staticconstexprsize_tkBufferSize =
+std::max(sizeof(uint64_t), sizeof(uint32_t) * 3);
+ v8::Global<v8::ArrayBuffer> array_buffer_;
+ std::shared_ptr<v8::BackingStore> backing_store_;
+
+// These need to be static so that we have their addresses available to
+// register as external references in the snapshot at environment creation
+// time.
+static v8::CFunction fast_number_;
+static v8::CFunction fast_bigint_;
+};
+
+} // namespace process
 } // namespace node
 #endif// defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 #endif// SRC_NODE_PROCESS_H_