nodejs学习笔记——关于V8

/**
An object reference managed by the v8 garbage collector.
    对象引用由v8垃圾回收管理

All objects returned from v8 have to be tracked by the garbage
collector so that it knows that the objects are still alive.
    所有从v8返回的对象，都被垃圾回收器追踪与知道对象是否活跃。

Also, because the garbage collector may move objects, it is unsafe to
point directly to an object.
    因为垃圾回收器可能会回收这个对象，如果使用指针直接指向一个对象的地址，那是不安全的。

Instead, all objects are stored in
handles which are known by the garbage collector and updated
whenever an object moves.  Handles should always be passed by value
(except in cases like out-parameters) and they should never be
allocated on the heap.
    所以，所有对象都存储在handles中，handle是被垃圾回收器管理，如果对象被回收就会更新handle.
    Handles一般是用作传参（在输出参数情况下除外），它们不应该被分配在堆heap中

There are two types of handles: local and persistent handles.
    handles有两种，Local 和 Persistent （局部的 与 持久的）

Local handles are light-weight and transient and typically used in
local operations.
    Local handles是轻量的，短暂使用的，一般用于局部的运算。（local本意是局部）

They are managed by HandleScopes. That means that a
HandleScope must exist on the stack when they are created and that they are
only valid inside of the HandleScope active during their creation.
    Local被HandleScopes管理，一个HandleScopes应该存储在栈stack中，当Local被创建后，
    当HandleScopes处于活跃期间，Local才是合法存在的（也就是说，HandleScopes不再处于活跃，Local对象就会被回收）


For passing a local handle to an outer HandleScope, an EscapableHandleScope
and its Escape() method must be used.
    如果，一个local handle传参到外部的HandleScope或者EscapableHandleScope，必须被使用它的Escape()方法
    （闭包的特性，escape逃逸是什么意思？）

Persistent handles can be used when storing objects across several
independent operations and have to be explicitly deallocated when they're no
longer used.
    Persistent handles(持久的对象)，可以被用于处理多个独立操作，它如果不在使用，必须被显式回收

It is safe to extract the object stored in the handle by
dereferencing the handle (for instance, to extract the Object* from
a Local<Object>);
    通过封装handle，提取存储在handle的对象，这是安全的。例如，从`Local<Object>`中提取`Object*`指针 ( 这是说把对象的操作等细节封装在Local类中，暴露出来public的函数是安全的 )

the value will still be governed by a handle
behind the scenes and the same rules apply to these values as to
their handles.
    对象的值由handle在背后处理

*/
template <class T>
class Local {
 public:
  V8_INLINE Local() : val_(0) {} // 没有参数的构造函数，初始化私有成员｀val_｀为０
  template <class S>
  V8_INLINE Local(Local<S> that)
      : val_(reinterpret_cast<T*>(*that)) {　// 传参同样是Local<S>的构造函数，初始化私有成员`val_`为传入的参数，并且检查类型S与T是否一样
    /**
     * This check fails when trying to convert between incompatible
     * handles. For example, converting from a Local<String> to a
     * Local<Number>.
     */
    TYPE_CHECK(T, S);
  }
//...

  // 重载操作符`->`，返回私有成员`val_`
  V8_INLINE T* operator->() const { return val_; }

  // 重载操作符`*`，返回私有成员`val_`
  V8_INLINE T* operator*() const { return val_; }

 // .....

 // Handle is an alias for Local for historical reasons.
 // 由于历史原因，Handle是Local的别名
template <class T>
using Handle = Local<T>;

class String16 {
 public:

    //explicit 避免隐式转换
  explicit String16(const std::basic_string<UChar>& impl) : m_impl(impl) {}

    // 重载操作符=，传入常量的对象的引用
  String16& operator=(const String16& other) {
    m_impl = other.m_impl;
    hash_code = other.hash_code;
    return *this;
  }

    // 重载操作符=，转移&&, 传入String16对象的右值
  String16& operator=(String16&& other) {
      // 左值引用转换为右值引用
    m_impl = std::move(other.m_impl);
    hash_code = other.hash_code;
    return *this;
  }

    // 重载操作符+，右操作数是String16对象引用
  inline String16 operator+(const String16& other) const {
    return String16(m_impl + other.m_impl);
  }
    // 重载操作符+, 左操作数是char*字符指针，右操作数是String16对象引用
  inline String16 operator+(const char* a, const String16& b) {
    return String16(a) + b;
  }

 private:
  std::basic_string<UChar> m_impl; // 私有m_impl实质上使用C++标准库的string对象，string对象的操作符+也是被重载过的
}

// After the handle scope of a local handle has been deleted the
// garbage collector will no longer track the object stored in the
// handle and may deallocate it.  The behavior of accessing a handle
// for which the handle scope has been deleted is undefined.
// 局部作用域的handle scope被销毁后，gc不在追踪存储在handle的对象而且回收它，表现在于访问这个作用域的对象会获得undefined
class HandleScope {
 public:
  explicit inline HandleScope(Isolate* isolate);

  // HandleScope 以链表的方式存储， Isolate是当前的虚拟机
  Isolate* isolate_;
  Object** prev_next_;
  Object** prev_limit_;

  // Close the handle scope resetting limits to a previous state.
  static inline void CloseScope(Isolate* isolate,
                                Object** prev_next,
                                Object** prev_limit);

  // Extend the handle scope making room for more handles.
  V8_EXPORT_PRIVATE static Object** Extend(Isolate* isolate);

};

Object** HandleScope::CreateHandle(Isolate* isolate, Object* value) {
  DCHECK(AllowHandleAllocation::IsAllowed());
  HandleScopeData* data = isolate->handle_scope_data();

  Object** result = data->next;
  if (result == data->limit) result = Extend(isolate);
  // Update the current next field, set the value in the created
  // handle, and return the result.
  DCHECK(result < data->limit);
  data->next = result + 1;

  *result = value;
  return result;
}

Object** HandleScope::GetHandle(Isolate* isolate, Object* value) {
  DCHECK(AllowHandleAllocation::IsAllowed());
  HandleScopeData* data = isolate->handle_scope_data();
  CanonicalHandleScope* canonical = data->canonical_scope;
  // 寻找对象 lookup
  return canonical ? canonical->Lookup(value) : CreateHandle(isolate, value);
}

/**
 * A sandboxed execution context with its own set of built-in objects
 * and functions.
  context是一个沙盒的执行上下文，放置内置的对象与函数
 */
class V8_EXPORT Context {
 public:
  /**
   * Returns the global proxy object.
      返回一个全局代理对象
   *
   * Global proxy object is a thin wrapper whose prototype points to actual
   * context's global object with the properties like Object, etc. This is done
   * that way for security reasons (for more details see
   * https://wiki.mozilla.org/Gecko:SplitWindow).
   *
   * Please note that changes to global proxy object prototype most probably
   * would break VM---v8 expects only global object as a prototype of global
   * proxy object.
   */
  Local<Object> Global();

  //...

  /**
   * Stack-allocated class which sets the execution context for all
   * operations executed within a local scope.
   */
  class Scope {
   public:
    explicit V8_INLINE Scope(Local<Context> context) : context_(context) {
      context_->Enter();
    }
    V8_INLINE ~Scope() { context_->Exit(); }

   private:
    Local<Context> context_;
  };

class Isolate {

  // True if at least one thread Enter'ed this isolate.
  // 线程进入前调用，确认能否进入
  bool IsInUse() { return entry_stack_ != NULL; }

  // Access to top context (where the current function object was created).
  // 返回当前上下文context，当function创建时，需要使用context
  Context* context() { return thread_local_top_.context_; }

  // Returns the global object of the current context. It could be
  // a builtin object, or a JS global object.
  // 获取全局对象
  inline Handle<JSGlobalObject> global_object();

  // Promise的相关函数
  // Push and pop a promise and the current try-catch handler.
  void PushPromise(Handle<JSObject> promise);
  void PopPromise();

  // Return the relevant Promise that a throw/rejection pertains to, based
  // on the contents of the Promise stack
  Handle<Object> GetPromiseOnStackOnThrow();

  // Heuristically guess whether a Promise is handled by user catch handler
  bool PromiseHasUserDefinedRejectHandler(Handle<Object> promise);

}

void Isolate::PushPromise(Handle<JSObject> promise) {
  ThreadLocalTop* tltop = thread_local_top();
  PromiseOnStack* prev = tltop->promise_on_stack_;
  Handle<JSObject> global_promise = global_handles()->Create(*promise);
  tltop->promise_on_stack_ = new PromiseOnStack(global_promise, prev);
}


void Isolate::PopPromise() {
  ThreadLocalTop* tltop = thread_local_top();
  if (tltop->promise_on_stack_ == NULL) return;
  PromiseOnStack* prev = tltop->promise_on_stack_->prev();
  Handle<Object> global_promise = tltop->promise_on_stack_->promise();
  delete tltop->promise_on_stack_;
  tltop->promise_on_stack_ = prev;
  global_handles()->Destroy(global_promise.location());
}