async_wrap: add uid to TickObject instances

So that each nextTick callback is treated as its own asynchronous event,
add a unique id to new TickObject instances. This is a preliminary for
allowing the async wrap callbacks to run with nextTick callbacks.

Author: trevnorris

lib/internal/async_wrap.js

@@ -0,0 +1,24 @@
+'use strict';
+
+const async_wrap = process.binding('async_wrap');
+const uidArray = async_wrap.getUidArray();
+
+module.exports.getUid =
+    process.binding('os').isBigEndian ? getUidBE : getUidLE;
+
+
+function getUidLE() {
+  if (uidArray[0] === 0xffffffff) {
+    uidArray[0] = 0;
+    uidArray[1]++;
+  }
+  return uidArray[0] + uidArray[1] * 0x100000000;
+}
+
+function getUidBE() {
+  if (uidArray[1] === 0xffffffff) {
+    uidArray[1] = 0;
+    uidArray[0]++;
+  }
+  return uidArray[1] + uidArray[0] * 0x100000000;
+}

lib/internal/process/next_tick.js

@@ -3,6 +3,7 @@
 exports.setup = setupNextTick;
 
 function setupNextTick() {
+  const async_wrap = require('internal/async_wrap');
   const promises = require('internal/process/promises');
   const emitPendingUnhandledRejections = promises.setup(scheduleMicrotasks);
   var nextTickQueue = [];
@@ -135,6 +136,7 @@ function setupNextTick() {
     this.callback = c;
     this.domain = process.domain || null;
     this.args = args;
+    this.uid = async_wrap.getUid();
   }
 
   function nextTick(callback) {

node.gyp

@@ -70,6 +70,7 @@
       'lib/v8.js',
       'lib/vm.js',
       'lib/zlib.js',
+      'lib/internal/async_wrap.js',
       'lib/internal/child_process.js',
       'lib/internal/cluster.js',
       'lib/internal/freelist.js',

src/async-wrap.cc

@@ -156,13 +156,20 @@ static void SetupHooks(const FunctionCallbackInfo<Value>& args) {
 }
 
 
+static void GetUidArray(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+  args.GetReturnValue().Set(env->async_hooks()->get_uid_array());
+}
+
+
 static void Initialize(Local<Object> target,
-                Local<Value> unused,
-                Local<Context> context) {
+                       Local<Value> unused,
+                       Local<Context> context) {
   Environment* env = Environment::GetCurrent(context);
   Isolate* isolate = env->isolate();
   HandleScope scope(isolate);
 
+  env->SetMethod(target, "getUidArray", GetUidArray);
   env->SetMethod(target, "setupHooks", SetupHooks);
   env->SetMethod(target, "disable", DisableHooksJS);
   env->SetMethod(target, "enable", EnableHooksJS);

src/env-inl.h

@@ -81,8 +81,18 @@ inline v8::Isolate* Environment::IsolateData::isolate() const {
   return isolate_;
 }
 
-inline Environment::AsyncHooks::AsyncHooks() {
+inline Environment::AsyncHooks::AsyncHooks(Environment* env)
+    : async_wrap_uid_(0),
+      env_(env) {
   for (int i = 0; i < kFieldsCount; i++) fields_[i] = 0;
+  const size_t array_length = sizeof(async_wrap_uid_) / sizeof(int32_t);
+  static_assert(array_length == 2, "async_wrap_uid_ unexpected size");
+  v8::HandleScope handle_scope(env_->isolate());
+  v8::Local<v8::ArrayBuffer> ab =
+      v8::ArrayBuffer::New(env_->isolate(), &async_wrap_uid_, array_length);
+  v8::Local<v8::Uint32Array> ua =
+      v8::Uint32Array::New(ab, 0, array_length);
+  async_wrap_uid_array_.Reset(env_->isolate(), ua);
 }
 
 inline uint32_t* Environment::AsyncHooks::fields() {
@@ -101,6 +111,14 @@ inline void Environment::AsyncHooks::set_enable_callbacks(uint32_t flag) {
   fields_[kEnableCallbacks] = flag;
 }
 
+inline int64_t Environment::AsyncHooks::get_async_wrap_uid() {
+  return ++async_wrap_uid_;
+}
+
+inline v8::Local<v8::Uint32Array> Environment::AsyncHooks::get_uid_array() {
+  return async_wrap_uid_array_.Get(env_->isolate());
+}
+
 inline Environment::AsyncCallbackScope::AsyncCallbackScope(Environment* env)
     : env_(env) {
   env_->makecallback_cntr_++;
@@ -216,12 +234,12 @@ inline Environment::Environment(v8::Local<v8::Context> context,
                                 uv_loop_t* loop)
     : isolate_(context->GetIsolate()),
       isolate_data_(IsolateData::GetOrCreate(context->GetIsolate(), loop)),
+      async_hooks_(this),
       timer_base_(uv_now(loop)),
       using_domains_(false),
       printed_error_(false),
       trace_sync_io_(false),
       makecallback_cntr_(0),
-      async_wrap_uid_(0),
       debugger_agent_(this),
       http_parser_buffer_(nullptr),
       context_(context->GetIsolate(), context) {
@@ -373,7 +391,7 @@ inline void Environment::set_trace_sync_io(bool value) {
 }
 
 inline int64_t Environment::get_async_wrap_uid() {
-  return ++async_wrap_uid_;
+  return async_hooks()->get_async_wrap_uid();
 }
 
 inline uint32_t* Environment::heap_statistics_buffer() const {

src/env.h

@@ -300,10 +300,13 @@ class Environment {
     inline int fields_count() const;
     inline bool callbacks_enabled();
     inline void set_enable_callbacks(uint32_t flag);
+    inline int64_t get_async_wrap_uid();
+    inline v8::Local<v8::Uint32Array> get_uid_array();
 
    private:
     friend class Environment;  // So we can call the constructor.
-    inline AsyncHooks();
+    inline AsyncHooks(Environment* env);
+    v8::Persistent<v8::Uint32Array> async_wrap_uid_array_;
 
     enum Fields {
       // Set this to not zero if the init hook should be called.
@@ -312,6 +315,8 @@ class Environment {
     };
 
     uint32_t fields_[kFieldsCount];
+    int64_t async_wrap_uid_;
+    Environment* env_;
 
     DISALLOW_COPY_AND_ASSIGN(AsyncHooks);
   };
@@ -577,7 +582,6 @@ class Environment {
   bool printed_error_;
   bool trace_sync_io_;
   size_t makecallback_cntr_;
-  int64_t async_wrap_uid_;
   debugger::Agent debugger_agent_;
 
   HandleWrapQueue handle_wrap_queue_;