GCC Code Coverage Report
Directory: ../ Exec Total Coverage
File: /home/iojs/build/workspace/node-test-commit-linux-coverage-daily/nodes/benchmark/out/../src/node_task_queue.cc Lines: 114 120 95.0 %
Date: 2021-06-10 04:11:54 Branches: 53 78 67.9 %

Line Branch Exec Source
1
#include "async_wrap.h"
2
#include "env-inl.h"
3
#include "node.h"
4
#include "node_errors.h"
5
#include "node_external_reference.h"
6
#include "node_internals.h"
7
#include "node_process-inl.h"
8
#include "util-inl.h"
9
#include "v8.h"
10
11
#include <atomic>
12
13
namespace node {
14
15
using errors::TryCatchScope;
16
using v8::Context;
17
using v8::Function;
18
using v8::FunctionCallbackInfo;
19
using v8::Isolate;
20
using v8::Just;
21
using v8::kPromiseHandlerAddedAfterReject;
22
using v8::kPromiseRejectAfterResolved;
23
using v8::kPromiseRejectWithNoHandler;
24
using v8::kPromiseResolveAfterResolved;
25
using v8::Local;
26
using v8::Maybe;
27
using v8::Number;
28
using v8::Object;
29
using v8::Promise;
30
using v8::PromiseRejectEvent;
31
using v8::PromiseRejectMessage;
32
using v8::Value;
33
34
41156
static Maybe<double> GetAssignedPromiseAsyncId(Environment* env,
35
                                               Local<Promise> promise,
36
                                               Local<Value> id_symbol) {
37
  Local<Value> maybe_async_id;
38
123468
  if (!promise->Get(env->context(), id_symbol).ToLocal(&maybe_async_id)) {
39
    return v8::Just(AsyncWrap::kInvalidAsyncId);
40
  }
41
41156
  return maybe_async_id->IsNumber()
42
      ? maybe_async_id->NumberValue(env->context())
43
41156
      : v8::Just(AsyncWrap::kInvalidAsyncId);
44
}
45
46
41156
static Maybe<double> GetAssignedPromiseWrapAsyncId(Environment* env,
47
                                                   Local<Promise> promise,
48
                                                   Local<Value> id_symbol) {
49
  // This check is imperfect. If the internal field is set, it should
50
  // be an object. If it's not, we just ignore it. Ideally v8 would
51
  // have had GetInternalField returning a MaybeLocal but this works
52
  // for now.
53
82312
  Local<Value> promiseWrap = promise->GetInternalField(0);
54
41156
  if (promiseWrap->IsObject()) {
55
        Local<Value> maybe_async_id;
56
64
    if (!promiseWrap.As<Object>()->Get(env->context(), id_symbol)
57
16
        .ToLocal(&maybe_async_id)) {
58
      return v8::Just(AsyncWrap::kInvalidAsyncId);
59
    }
60
16
    return maybe_async_id->IsNumber()
61
32
        ? maybe_async_id->NumberValue(env->context())
62
32
        : v8::Just(AsyncWrap::kInvalidAsyncId);
63
  } else {
64
41140
      return v8::Just(AsyncWrap::kInvalidAsyncId);
65
  }
66
}
67
68
20579
void PromiseRejectCallback(PromiseRejectMessage message) {
69
  static std::atomic<uint64_t> unhandledRejections{0};
70
  static std::atomic<uint64_t> rejectionsHandledAfter{0};
71
72
20579
  Local<Promise> promise = message.GetPromise();
73
20579
  Isolate* isolate = promise->GetIsolate();
74
20579
  PromiseRejectEvent event = message.GetEvent();
75
76
20579
  Environment* env = Environment::GetCurrent(isolate);
77
78

20580
  if (env == nullptr || !env->can_call_into_js()) return;
79
80
20578
  Local<Function> callback = env->promise_reject_callback();
81
  // The promise is rejected before JS land calls SetPromiseRejectCallback
82
  // to initializes the promise reject callback during bootstrap.
83
20578
  CHECK(!callback.IsEmpty());
84
85
  Local<Value> value;
86
20578
  Local<Value> type = Number::New(env->isolate(), event);
87
88
20578
  if (event == kPromiseRejectWithNoHandler) {
89
4796
    value = message.GetValue();
90
4796
    unhandledRejections++;
91
4796
    TRACE_COUNTER2(TRACING_CATEGORY_NODE2(promises, rejections),
92
                  "rejections",
93
                  "unhandled", unhandledRejections,
94
158
                  "handledAfter", rejectionsHandledAfter);
95

25532
  } else if (event == kPromiseHandlerAddedAfterReject) {
96
8195
    value = Undefined(isolate);
97
3399
    rejectionsHandledAfter++;
98
4
    TRACE_COUNTER2(TRACING_CATEGORY_NODE2(promises, rejections),
99
3403
                  "rejections",
100
                  "unhandled", unhandledRejections,
101
136
                  "handledAfter", rejectionsHandledAfter);
102

19317
  } else if (event == kPromiseResolveAfterResolved) {
103
3471
    value = message.GetValue();
104
12311
  } else if (event == kPromiseRejectAfterResolved) {
105
12311
    value = message.GetValue();
106
  } else {
107
    return;
108
  }
109
110
20578
  if (value.IsEmpty()) {
111
    value = Undefined(isolate);
112
  }
113
114
41156
  Local<Value> args[] = { type, promise, value };
115
116
20578
  double async_id = AsyncWrap::kInvalidAsyncId;
117
20578
  double trigger_async_id = AsyncWrap::kInvalidAsyncId;
118
41156
  TryCatchScope try_catch(env);
119
120
61734
  if (!GetAssignedPromiseAsyncId(env, promise, env->async_id_symbol())
121
20578
          .To(&async_id)) return;
122
61734
  if (!GetAssignedPromiseAsyncId(env, promise, env->trigger_async_id_symbol())
123
20578
          .To(&trigger_async_id)) return;
124
125

41156
  if (async_id == AsyncWrap::kInvalidAsyncId &&
126
20578
      trigger_async_id == AsyncWrap::kInvalidAsyncId) {
127
    // That means that promise might be a PromiseWrap, so we'll
128
    // check there as well.
129
61734
    if (!GetAssignedPromiseWrapAsyncId(env, promise, env->async_id_symbol())
130
20578
              .To(&async_id)) return;
131
61734
    if (!GetAssignedPromiseWrapAsyncId(
132
41156
          env, promise, env->trigger_async_id_symbol())
133
20578
              .To(&trigger_async_id)) return;
134
  }
135
136

20586
  if (async_id != AsyncWrap::kInvalidAsyncId &&
137
8
      trigger_async_id != AsyncWrap::kInvalidAsyncId) {
138
16
    env->async_hooks()->push_async_context(
139
16
        async_id, trigger_async_id, promise);
140
  }
141
142
41156
  USE(callback->Call(
143
102890
      env->context(), Undefined(isolate), arraysize(args), args));
144
145

41164
  if (async_id != AsyncWrap::kInvalidAsyncId &&
146

20586
      trigger_async_id != AsyncWrap::kInvalidAsyncId &&
147
8
      env->execution_async_id() == async_id) {
148
    // This condition might not be true if async_hooks was enabled during
149
    // the promise callback execution.
150
8
    env->async_hooks()->pop_async_context(async_id);
151
  }
152
153
  // V8 does not expect this callback to have a scheduled exceptions once it
154
  // returns, so we print them out in a best effort to do something about it
155
  // without failing silently and without crashing the process.
156

20578
  if (try_catch.HasCaught() && !try_catch.HasTerminated()) {
157
396
    fprintf(stderr, "Exception in PromiseRejectCallback:\n");
158
396
    PrintCaughtException(isolate, env->context(), try_catch);
159
  }
160
}
161
namespace task_queue {
162
163
349
static void EnqueueMicrotask(const FunctionCallbackInfo<Value>& args) {
164
349
  Environment* env = Environment::GetCurrent(args);
165
349
  Isolate* isolate = env->isolate();
166
167
698
  CHECK(args[0]->IsFunction());
168
169
1047
  isolate->GetCurrentContext()->GetMicrotaskQueue()
170
1047
      ->EnqueueMicrotask(isolate, args[0].As<Function>());
171
349
}
172
173
202627
static void RunMicrotasks(const FunctionCallbackInfo<Value>& args) {
174
202627
  Environment* env = Environment::GetCurrent(args);
175
405254
  env->context()->GetMicrotaskQueue()->PerformCheckpoint(env->isolate());
176
202624
}
177
178
455
static void SetTickCallback(const FunctionCallbackInfo<Value>& args) {
179
455
  Environment* env = Environment::GetCurrent(args);
180
910
  CHECK(args[0]->IsFunction());
181
910
  env->set_tick_callback_function(args[0].As<Function>());
182
455
}
183
184
455
static void SetPromiseRejectCallback(
185
    const FunctionCallbackInfo<Value>& args) {
186
455
  Environment* env = Environment::GetCurrent(args);
187
188
910
  CHECK(args[0]->IsFunction());
189
910
  env->set_promise_reject_callback(args[0].As<Function>());
190
455
}
191
192
455
static void Initialize(Local<Object> target,
193
                       Local<Value> unused,
194
                       Local<Context> context,
195
                       void* priv) {
196
455
  Environment* env = Environment::GetCurrent(context);
197
455
  Isolate* isolate = env->isolate();
198
199
455
  env->SetMethod(target, "enqueueMicrotask", EnqueueMicrotask);
200
455
  env->SetMethod(target, "setTickCallback", SetTickCallback);
201
455
  env->SetMethod(target, "runMicrotasks", RunMicrotasks);
202
910
  target->Set(env->context(),
203
              FIXED_ONE_BYTE_STRING(isolate, "tickInfo"),
204
1365
              env->tick_info()->fields().GetJSArray()).Check();
205
206
455
  Local<Object> events = Object::New(isolate);
207
910
  NODE_DEFINE_CONSTANT(events, kPromiseRejectWithNoHandler);
208
455
  NODE_DEFINE_CONSTANT(events, kPromiseHandlerAddedAfterReject);
209
2275
  NODE_DEFINE_CONSTANT(events, kPromiseResolveAfterResolved);
210
2275
  NODE_DEFINE_CONSTANT(events, kPromiseRejectAfterResolved);
211
2730
212
3185
  target->Set(env->context(),
213
1365
              FIXED_ONE_BYTE_STRING(isolate, "promiseRejectEvents"),
214
2730
              events).Check();
215
  env->SetMethod(target,
216
                 "setPromiseRejectCallback",
217
455
                 SetPromiseRejectCallback);
218
455
}
219
220
4767
void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
221
4767
  registry->Register(EnqueueMicrotask);
222
4767
  registry->Register(SetTickCallback);
223
4767
  registry->Register(RunMicrotasks);
224
4767
  registry->Register(SetPromiseRejectCallback);
225
4767
}
226
227
}  // namespace task_queue
228
}  // namespace node
229
230
4838
NODE_MODULE_CONTEXT_AWARE_INTERNAL(task_queue, node::task_queue::Initialize)
231

19305
NODE_MODULE_EXTERNAL_REFERENCE(task_queue,
232
                               node::task_queue::RegisterExternalReferences)