理解nodejs中js和c++的通信原理
发布于 25 天前 作者 theanarkh 2361 次浏览 来自 分享

本文分享一下nodejs中js调用c++模块的一些内容。js调用c++模块是v8提供的能力,nodejs是使用了这个能力。这样我们只需要面对js,剩下的事情交给nodejs就行。本文首先讲一下利用v8如何实现js调用c++,然后再讲一下nodejs是怎么做的。

1 js调用c++

首先介绍一下v8中两个非常核心的类FunctionTemplate和ObjectTemplate。顾名思义,这两个类是定义模板的,好比建房子时的设计图一样,通过设计图,我们就可以造出对应的房子。v8也是,定义某种模板,就可以通过这个模板创建出对应的实例。下面介绍一下这些概念(为了方便,下面都是伪代码)。

1.1 定义一个函数模板

Local<FunctionTemplate> exampleFunctionTemplate = v8::FunctionTemplate::New(isolate(), New);
// 定义函数的类名
exampleFunctionTemplate->SetClassName(‘TCP’)

首先定义一个FunctionTemplate对象。我们看到FunctionTemplate的第二个入参是一个函数,当我们执行由FunctionTemplate创建的函数时,v8就会执行New函数。当然我们也可以不传。

1.2 定义函数模板的prototype内容

prototype就是js里的function.prototype。如果你理解js里的知识,就很容易理解c++的代码。

  v8::Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(isolate(), callback);
  t->SetClassName('test'); 
  // 在prototype上定义两个属性
  exampleFunctionTemplate->PrototypeTemplate()->Set('name', t);
  exampleFunctionTemplate->PrototypeTemplate()->Set('hello', 'world');

1.3 定义函数模板对应的实例模板的内容

实例模板就是一个ObjectTemplate对象。他定义了,当以new的方式执行由函数模板创建出来的函数时的返回值。

function A() {
	this.a = 1;
	this.b = 2;
}
new A();

实例模板类似上面代码中A函数里面的代码。我们看看在v8里怎么定义。

t->InstanceTemplate()->Set(key, val);
t->InstanceTemplate()->SetInternalFieldCount(1);

InstanceTemplate返回的是一个ObjectTemplate对象。SetInternalFieldCount这个函数比较特殊,也是比较重要的一个地方,我们知道对象就是一块内存,对象有他自己的内存布局,我们知道在c++里,我们定义一个类,也就定义了对象的布局。比如我们有以下定义。

class demo
{
    private:
    int a;
    int b;
};

在内存中布局如下。 上面这种方式有个问题,就是类定义之后,内存布局就固定了。而v8是自己去控制对象的内存布局的。当我们在v8中定义一个类的时候,是没有任何属性的。我们看一下v8中HeapObject类的定义。

class HeapObject: public Object {
  static const int kMapOffset = Object::kSize; // Object::kSize是0
  static const int kSize = kMapOffset + kPointerSize;
};

这时候的内存布局如下。 然后我们再看一下HeapObject子类HeapNumber的定义。

class HeapNumber: public HeapObject {
  // kSize之前的空间存储map对象的指针
  static const int kValueOffset = HeapObject::kSize;
  // kValueOffset - kSize之间存储数字的值
  static const int kSize = kValueOffset + kDoubleSize;
};

内存布局如下

我们发现这些类只有几个类变量,类变量是不保存在对象内存空间的。这些类变量就是定义了对象每个域所占内存空间的信息,当我们定义一个HeapObject对象的时候,v8首先申请一块内存,然后把这块内存首地址强行转成对应对象的指针。然后通过类变量对属性的内存进行存取。我们看看在v8里如何申请一个HeapNumber对象

Object* Heap::AllocateHeapNumber(double value, PretenureFlag pretenure) {
  // 在哪个空间分配内存,比如新生代,老生代
  AllocationSpace space = (pretenure == TENURED) ? CODE_SPACE : NEW_SPACE;
  // 在space上分配一个HeapNumber对象大小的内存
  Object* result = AllocateRaw(HeapNumber::kSize, space);
  /*
	  转成HeapObect,设置map属性,map属性是表示对象类型、大小等信息的
  */
  HeapObject::cast(result)->set_map(heap_number_map());
  // 转成HeapNumber对象
  HeapNumber::cast(result)->set_value(value);
  return result;
}

回到对象模板的问题。我们看一下对象模板的定义。

class TemplateInfo: public Struct {
  static const int kTagOffset          = HeapObject::kSize;
  static const int kPropertyListOffset = kTagOffset + kPointerSize;
  static const int kHeaderSize         = kPropertyListOffset + kPointerSize;
};

class ObjectTemplateInfo: public TemplateInfo {
  static const int kConstructorOffset = TemplateInfo::kHeaderSize;
  static const int kInternalFieldCountOffset = kConstructorOffset + kPointerSize;
  static const int kSize = kInternalFieldCountOffset + kHeaderSize;
};

内存布局如下

回到对象模板的问题,我们看看Set(key, val)做了什么。

void Template::Set(v8::Handle<String> name, v8::Handle<Data> value,
                   v8::PropertyAttribute attribute) {
  // ...
  i::Handle<i::Object> list(Utils::OpenHandle(this)->property_list());
  NeanderArray array(list);
  array.add(Utils::OpenHandle(*name));
  array.add(Utils::OpenHandle(*value));
  array.add(Utils::OpenHandle(*v8::Integer::New(attribute)));
}

上面的代码大致就是给一个list后面追加一些内容。我们看看这个list是怎么来的,即property_list函数的实现。

// 读取对象中某个属性的值
#define READ_FIELD(p, offset) (*reinterpret_cast<Object**>(FIELD_ADDR(p, offset))

static Object* cast(Object* value) { 
	return value;
}

Object* TemplateInfo::property_list() { 
	return Object::cast(READ_FIELD(this, kPropertyListOffset)); 
}

从上面代码中我们知道,内部布局如下。

根据内存布局,我们知道property_list的值是list指向的值。所以Set(key, val)操作的内存并不是对象本身的内存,对象利用一个指针指向一块内存保存Set(key, val)的值。SetInternalFieldCount函数就不一样了,他会影响(扩张)对象本身的内存。我们来看一下他的实现。

void ObjectTemplate::SetInternalFieldCount(int value) {
  // 修改的是kInternalFieldCountOffset对应的内存的值
  Utils::OpenHandle(this)->set_internal_field_count(i::Smi::FromInt(value));
}

我们看到SetInternalFieldCount函数的实现很简单,就是在对象本身的内存中保存一个数字。接下来我们看看这个字段的使用。后面会详细介绍他的用处。

Handle<JSFunction> Factory::CreateApiFunction(
    Handle<FunctionTemplateInfo> obj,
    bool is_global) {
 
  int internal_field_count = 0;
  if (!obj->instance_template()->IsUndefined()) {
    // 获取函数模板的实例模板
    Handle<ObjectTemplateInfo> instance_template = Handle<ObjectTemplateInfo>(ObjectTemplateInfo::cast(obj->instance_template()));
    // 获取实例模板的internal_field_count字段的值(通过SetInternalFieldCount设置的那个值)
    internal_field_count = Smi::cast(instance_template->internal_field_count())->value();
  }
  // 计算新建对象需要的空间,如果
  int instance_size = kPointerSize * internal_field_count;
  if (is_global) {
    instance_size += JSGlobalObject::kSize;
  } else {
    instance_size += JSObject::kHeaderSize;
  }

  InstanceType type = is_global ? JS_GLOBAL_OBJECT_TYPE : JS_OBJECT_TYPE;
  // 新建一个函数对象
  Handle<JSFunction> result =
      Factory::NewFunction(Factory::empty_symbol(), type, instance_size,
                           code, true);
}                       

我们看到internal_field_count的值的意义是,会扩张对象的内存,比如一个对象本身只有n字节,如果定义internal_field_count的值是1,对象的内存就会变成n+internal_field_count * 一个指针的字节数。内存布局如下。 1.4 通过函数模板创建一个函数

AFunctionTemplate->GetFunction();
global->Set('demo', AFunctionTemplate->GetFunction());

这样我们就可以在js里直接调用demo这个变量,然后对应的函数就会被执行。这就是js调用c++的原理。

2 nodejs是如何处理js调用c++问题的

nodejs没有给每个功能定义一个全局变量,而是通过另外一种方式实现js调用c++。我们以tcp模块为例。在tcp_wrap.cc文件最后有一句代码

NODE_BUILTIN_MODULE_CONTEXT_AWARE(tcp_wrap, node::TCPWrap::Initialize)

这是一个宏,展开后如下

#define NODE_BUILTIN_MODULE_CONTEXT_AWARE(modname, regfunc)                   \
  NODE_MODULE_CONTEXT_AWARE_CPP(modname, regfunc, nullptr, NM_F_BUILTIN)


#define NODE_MODULE_CONTEXT_AWARE_CPP(modname, regfunc, priv, flags)          \
  static node::node_module _module = {                                        \
    NODE_MODULE_VERSION,                                                      \
    flags,                                                                    \
    nullptr,                                                                  \
    __FILE__,                                                                 \
    nullptr,                                                                  \
    (node::addon_context_register_func) (regfunc),                            \
    NODE_STRINGIFY(modname),                                                  \
    priv,                                                                     \
    nullptr                                                                   \
  };                                                                          \
  void _register_ ## modname() {                                              \
    node_module_register(&_module);                                           \
  }

我们看到,宏展开后,首先定义了一个node_module 结构体。然后定义了一个_register_ xxx的函数。这个函数在nodejs初始化的时候会执行

void RegisterBuiltinModules() {
// 宏展开后就是执行一系列的_register_xxx函数
#define V(modname) _register_##modname();
  NODE_BUILTIN_MODULES(V)
#undef V
}

我们看到_register_ xxx函数执行了

node_module_register(&_module);

node_module_register定义如下

extern "C" void node_module_register(void* m) {
  struct node_module* mp = reinterpret_cast<struct node_module*>(m);
  mp->nm_link = modlist_builtin;
  modlist_builtin = mp;
}

就是把一个个node_module加入到链表中。完成了模块的注册。我们来看看如何使用这个模块。

constant { TCP } = process.binding('tcp_wrap');
new TCP(...);

我们看到nodejs是通过process.binding来实现c++模块的调用的。nodejs通过定义一个全局变量process统一处理c++模块的调用,而不是定义一堆全局对象。下面我们看process.binding的实现,跳过nodejs的缓存处理,直接看c++的实现。


static Local<Object> InitModule(Environment* env,
                                 node_module* mod,
                                 Local<String> module) {
  Local<Object> exports = Object::New(env->isolate());
  Local<Value> unused = Undefined(env->isolate());
  // 执行nm_context_register_func函数,就是tcp_wrap.cc的Initialize函数
  mod->nm_context_register_func(exports,
                                unused,
                                env->context(),
                                mod->nm_priv);
  return exports;
}

static void Binding(const FunctionCallbackInfo<Value>& args) {
  Environment* env = Environment::GetCurrent(args);
  Local<String> module = args[0].As<String>();
  node::Utf8Value module_v(env->isolate(), module);
  // 从模块链表中找到对应的模块
  node_module* mod = get_builtin_module(*module_v);
  Local<Object> exports = InitModule(env, mod, module);
  args.GetReturnValue().Set(exports);
}

v8中,js调用c++函数的规则是函数入参const FunctionCallbackInfo<Value>& args(拿到js传过来的内容)和设置返回值args.GetReturnValue().Set(给js返回的内容);binding函数的逻辑就是执行对应的模块钩子函数,并有一个exports变量传进去,然后钩子函数会修改exports的值,该exports的值就是js层能拿到的值。最后我们来看看tcp_wrap.cc的Initialize。

void TCPWrap::Initialize(Local<Object> target,
                         Local<Value> unused,
                         Local<Context> context) {
  Environment* env = Environment::GetCurrent(context);
  /*
    new TCP时,v8会新建一个c++对象(根据InstanceTemplate()模板创建的对象),然后传进New函数,
    然后执行New函数,New函数的入参args的args.This()就是该c++对象
  */
  Local<FunctionTemplate> t = env->NewFunctionTemplate(New);
  Local<String> tcpString = FIXED_ONE_BYTE_STRING(env->isolate(), "TCP");
  t->SetClassName(tcpString);
  t->InstanceTemplate()->SetInternalFieldCount(1);
  t->InstanceTemplate()->Set(env->owner_string(), Null(env->isolate()));
  // ...
  // 在target(即exports对象)中注册该函数
  target->Set(tcpString, t->GetFunction());

上面就定义了我们在js层可以拿到的值。今天就分析到这,后续再补充。 如果你对nodejs感兴趣欢迎关注我的公众号。 image.png

回到顶部