服务器之家

服务器之家 > 正文

聊聊No.js---基于V8和io_uring的JS运行时

时间：2021-09-06 23:19     来源/作者：编程杂技

聊聊No.js---基于V8和io_uring的JS运行时

前言：阅读Node.js的源码已经有一段时间了，最近也看了一下新的JS运行时Just的一些实现，就产生了自己写一个JS运行时的想法，虽然几个月前就基于V8写了一个简单的JS运行时，但功能比较简单，这次废弃了之前的代码，重新写了一遍，写这个JS运行时的目的最主要是为了学习，事实也证明，写一个JS运行时的确可以学到很多东西。本文介绍运行时No.js的一些设计和实现，取名No.js一来是受Node.js的影响，二来是为了说明不仅仅是JS，也就是利用V8拓展了JS的功能，同时，前端开发者要学习的知识也不仅仅是JS了。

1 为什么选io_uring

io_uring是Linux下新一代的高性能异步IO框架，也是No.js的核心。在No.js中，io_uring用于实现事件循环。为什么不选用epoll呢?因为epoll不支持文件IO，如果选用epoll，还需要自己实现一个线程池，还需要实现线程和主线程的通信，以及线程池任务和事件循环的融合，No.js希望把事件变得纯粹，简单。而io_uring是支持异步文件IO的，并且io_uring是真正的异步IO框架，支持的功能也非常丰富，比如在epoll里我们监听一个socket后，需要把socket fd注册到epoll中，等待有连接时执行回调，然后调用accept获取新的fd，而io_uring直接就帮我们获取新的fd，io_uring通知我们的时候，我们就已经拿到新的fd了，epoll时代，epoll通知我们可以做什么事情了，然后我们自己去做，io_uring时代，io_uring通知我们什么事情完成了。

2 No.js框架的设计

No.js目前的实现比较清晰简单，所有的功能都通过c和c++实现，然后通过V8暴露给JS实现。No.cc是初始化的入口，core目录是所有功能实现的地方，core下面按照模块功能划分。下面我们看看整体的框架实现。

  1. int main(int argc, char* argv[]) { 
  2.   // ... 
  3.   Isolate* isolate = Isolate::New(create_params); 
  4.   { 
  5.     Isolate::Scope isolate_scope(isolate); 
  6.     HandleScope handle_scope(isolate); 
  7.     // 创建全局对象 
  8.     Local<ObjectTemplate> global = ObjectTemplate::New(isolate); 
  9.     // 创建执行上下文 
  10.     Local<Context> context = Context::New(isolate, nullptr, global); 
  11.     Environment * env = new Environment(context); 
  12.     Context::Scope context_scope(context); 
  13.     // 创建No，核心对象 
  14.     Local<Object> No = Object::New(isolate); 
  15.     // 注册c、c++模块 
  16.     register_builtins(isolate, No); 
  17.     // 获取全局对象 
  18.     Local<Object> globalInstance = context->Global(); 
  19.     // 设置全局属性 
  20.     globalInstance->Set(context, String::NewFromUtf8Literal(isolate, "No",  
  21.     NewStringType::kNormal), No); 
  22.     // 设置全局属性global指向全局对象 
  23.     globalInstance->Set(context, String::NewFromUtf8Literal(isolate,  
  24.       "global",  
  25.       NewStringType::kNormal), globalInstance).Check(); 
  26.     { 
  27.       // 打开文件 
  28.       int fd = open(argv[1], O_RDONLY); 
  29.       struct stat info; 
  30.       // 取得文件信息 
  31.       fstat(fd, &info); 
  32.       // 分配内存保存文件内容 
  33.       char *ptr = (char *)malloc(info.st_size + 1); 
  34.       read(fd, (void *)ptr, info.st_size); 
  35.       // 要执行的js代码 
  36.       Local<String> source = String::NewFromUtf8(isolate, ptr, 
  37.                           NewStringType::kNormal, 
  38.                           info.st_size).ToLocalChecked(); 
  39.  
  40.       // 编译 
  41.       Local<Script> script = Script::Compile(context, source).ToLocalChecked(); 
  42.       // 解析完应该没用了，释放内存 
  43.       free(ptr); 
  44.       // 执行 
  45.       Local<Value> result = script->Run(context).ToLocalChecked(); 
  46.       // 进入事件循环 
  47.       Run(env->GetIOUringData()); 
  48.     } 
  49.   } 
  50.   return 0; 
  51.  
  52. } 

大部分逻辑都是V8初始化的标准流程，添加的内容主要包括注册c、c++模块、挂载No到全局作用域、开启事件循环。

2.1 注册模块

No在初始化的时候会把所有C++模块注册到No中，因为No是全局属性，所以在JS里可以直接访问C++模块，不需要require。我们看看register_builtins。

  1. void No::Core::register_builtins(Isolate * isolate, Local<Object> target) { 
  2.     FS::Init(isolate, target);  
  3.     TCP::Init(isolate, target);  
  4.     Process::Init(isolate, target);  
  5.     Console::Init(isolate, target); 
  6.     IO::Init(isolate, target); 
  7.     Net::Init(isolate, target); 
  8.     UDP::Init(isolate, target); 
  9.     UNIX_DOMAIN::Init(isolate, target); 
  10.     Signal::Init(isolate, target); 
  11.     Timer::Init(isolate, target); 
  12.  
  13. } 

register_builtins会调用各个模块的Init函数，各个模块自己实现需要挂载的功能，从代码中可以看到目前实现的功能。我们随便找一个模块看看初始化的逻辑。

  1. void No::FS::Init(Isolate* isolate, Local<Object> target) { 
  2.   Local<ObjectTemplate> fs = ObjectTemplate::New(isolate); 
  3.   setMethod(isolate, fs, "open", No::FS::Open); 
  4.   setMethod(isolate, fs, "openat", No::FS::OpenAt); 
  5.   setMethod(isolate, fs, "close", No::IO::Close); 
  6.   setMethod(isolate, fs, "read", No::IO::Read); 
  7.   setMethod(isolate, fs, "write", No::IO::Write); 
  8.   setMethod(isolate, fs, "readv", No::IO::ReadV); 
  9.   setMethod(isolate, fs, "writev", No::IO::WriteV); 
  10.   setObjectValue(isolate, target, "fs", fs->NewInstance(isolate->GetCurrentContext()).ToLocalChecked()); 
  11.  
  12. } 

挂载的逻辑就是新建一个对象，然后设置对象的属性，最后把这个对象作为No对象的一个属性挂载到No中，最后形成如下一个结构。

  1. var No = { 
  2.     fs: {}, 
  3.     tcp: {} 
  4.  
  5. } 

这就完成了所有核心模块的注册。

2.2 执行JS

注册完核心模块后就是执行业务JS。我们随便看个例子。

  1. const { 
  2.     fs, 
  3.     console 
  4. } = No;const fd = fs.open('./test/file/1.txt');const arr = new ArrayBuffer(100); 
  5. fs.readv(fd,arr , 0, (res) => {console.log(res)}); 
  6. console.log(new Uint8Array(arr)); 

以上是读取一个文件的例子，从中也可以看到No的使用方式。No没有实现类似Node.js的Buffer，是直接使用V8的ArrayBuffer的，ArrayBuffer使用的是V8堆外内存，readv是C++层实现的函数，我们一会单独介绍。

2.3 开启事件循环

执行完JS后，最后进入事件循环。

  1. void No::io_uring::RunIOUring(struct io_uring_info *io_uring_data) { 
  2.     struct io_uring* ring = &io_uring_data->ring; 
  3.     struct io_uring_cqe* cqe; 
  4.     struct request* req; 
  5.     while(io_uring_data->stop != 1 && io_uring_data->pending != 0) { 
  6.         // 提交请求给内核 
  7.         int count = io_uring_submit_and_wait(ring, 1); 
  8.         // 处理每一个完成的请求 
  9.         while (1) {  
  10.             io_uring_peek_cqe(ring, &cqe); 
  11.             if (cqe == NULL) 
  12.                 break; 
  13.             --io_uring_data->pending; 
  14.             // 拿到请求上下文 
  15.             req = (struct request*) (uintptr_t) cqe->user_data; 
  16.             req->res = cqe->res; 
  17.             io_uring_cq_advance(ring, 1); 
  18.             // 执行回调 
  19.             if (req->cb != nullptr) { 
  20.                 req->cb((void *)req); 
  21.             } 
  22.         } 
  23.     } 
  24.  
  25. } 

从事件循环的代码中大致可以看到原理，首先判断事件循环是不是停止或者可以停止了，如果还没有停止，则等待任务完成，然后取出任务执行任务的对象。

3 任务的封装和处理

io_uring的任务是以结构体io_uring_sqe表示的，但是io_uring_sqe只是记录了和io_uring框架本身相关的一些数据结构，因为是异步的模式，所以在任务完成的时候，我们需要知道，这个任务关联的上下文和回调。io_uring_sqe提供了user_data字段用于保存请求对应的上下文。流程如下。设置和提交请求

  1. // 获取一个io_uring的请求结构体 
  2.  struct io_uring_sqe *sqe = io_uring_get_sqe(&io_uring_data->ring); 
  3.  // 自定义结构体 
  4.  struct io_request * file_req = (struct io_request *)req; 
  5.  // 设置请求的字段 
  6.  io_uring_prep_read(sqe, file_req->fd, file_req->buf, file_req->len, file_req->offset); 
  7.  // 保存请求上下文，响应的时候用 
  8.  io_uring_sqe_set_data(sqe, (void *)req); 
  9.  // 提交请求 
  10.  io_uring_submit(&io_uring_data->ring); 

我们看到提交请求的时候，设置了请求上下文是我们自定义的结构体，具体结构体类型根据操作类型而不同。我们看看请求完成时是如何处理的。

  1. struct io_uring_cqe* cqe;io_uring_peek_cqe(ring, &cqe);// 拿到请求上下文 
  2. req = (struct request*) (uintptr_t) cqe->user_data;// 记录请求结果 
  3. req->res = cqe->res; 
  4. req->cb((void *)req); 

以上就是一个No请求和响应的处理过程。No为不同的操作类型封装了不同的结构体。首先封装了一个请求的基类。

  1. #define REQUEST \ 
  2.         int op; \ 
  3.         // io_uring执行的回调 
  4.         request_cb cb; \ 
  5.         // io_uring请求的结果 
  6.         int res;\ 
  7.         // 业务上下文 
  8.         void * data; \ 
  9.         int flag; 

类似io_uring通过user_data字段关联请求响应上下文。REQUEST 里通过data关联请求和响应上下文，通过user_data字段，我们在任务完成时可以执行应该执行哪个回调以及对应的上下文。但是执行某个回调时，该回调函数需要的上下文可能不仅仅是io_uring返回的结果，这时候就可以使用data字段记录额外的上下文。一会会具体介绍。基于REQUEST，针对不同的操作封装了不同的结构体，比如文件请求。

  1. struct io_request { 
  2.     REQUEST 
  3.     int fd;  
  4.     int offset;  
  5.     void *buf; 
  6.     int len;  
  7. }; 

下面我们分析一个具体请求的过程，这里以read为例。

  1. void read_write_request(V8_ARGS, int op) {  
  2.     V8_ISOLATE 
  3.     int fd = args[0].As<Uint32>()->Value(); 
  4.     int offset = 0; 
  5.     if (args.Length() > 2 && args[2]->IsNumber()) { 
  6.         offset = args[2].As<Integer>()->Value(); 
  7.     } 
  8.     Local<ArrayBuffer> arrayBuffer = args[1].As<ArrayBuffer>(); 
  9.     std::shared_ptr<BackingStore> backing = arrayBuffer->GetBackingStore(); 
  10.     V8_CONTEXT 
  11.     Environment *env = Environment::GetEnvByContext(context); 
  12.     struct io_uring_info *io_uring_data = env->GetIOUringData(); 
  13.     struct request *req; 
  14.     // 文件操作对应的request结构体 
  15.     struct io_request *io_req = (struct io_request *)malloc(sizeof(struct io_request)); 
  16.     memset(io_req, 0, sizeof(*io_req)); 
  17.     io_req->buf = backing->Data(); 
  18.     io_req->len = backing->ByteLength(); 
  19.     io_req->fd = fd; 
  20.     io_req->offset = offset; 
  21.     req = (struct request *)io_req; 
  22.     // JS层回调 
  23.     req->cb = makeCallback<onread>; 
  24.     req->op = op; 
  25.     // 保存回调上下文 
  26.     if (args.Length() > 3 && args[3]->IsFunction()) { 
  27.         Local<Object> obj = Object::New(isolate); 
  28.         Local<String> key = newStringToLcal(isolate, onread); 
  29.         obj->Set(context, key, args[3].As<Function>()); 
  30.         req->data = (void *)new RequestContext(env, obj); 
  31.     } else { 
  32.         req->data = (void *)new RequestContext(env, Local<Function>()); 
  33.     } 
  34.     // 提交请求 
  35.     SubmitRequest((struct request *)req, io_uring_data);   
  36. } 

初始化请求的上下文后，调用SubmitRequest提交任务和io_uring。我们看看SubmitRequest。

  1. void No::io_uring::SubmitRequest(struct request * req, struct io_uring_info *io_uring_data) { 
  2.     // 获取一个io_uring的请求结构体 
  3.     struct io_uring_sqe *sqe = io_uring_get_sqe(&io_uring_data->ring); 
  4.     // 填充请求 
  5.     switch (req->op) 
  6.     { 
  7.  
  8.         case IORING_OP_READ: 
  9.             { 
  10.                 struct io_request * file_req = (struct io_request *)req; 
  11.                 io_uring_prep_read(sqe, file_req->fd, file_req->buf, file_req->len, file_req->offset); 
  12.                 break; 
  13.             } 
  14.         default: 
  15.             return; 
  16.     } 
  17.     ++io_uring_data->pending; 
  18.     // 保存请求上下文，响应的时候用 
  19.     io_uring_sqe_set_data(sqe, (void *)req); 
  20.     io_uring_submit(&io_uring_data->ring); 
  21.  
  22. } 

SubmitRequest根据不同的操作设置io_uring的请求结构体，并保存对应的请求上下文。当任务完成时执行回调makeCallback。makeCallback是模板函数。

  1. template <const char * event> 
  2.   void makeCallback(void * req) { 
  3.        struct request * _req = (struct request *)req; 
  4.        RequestContext* ctx =(RequestContext *)_req->data; 
  5.        if (!ctx->object.IsEmpty()) { 
  6.            Local<Object> object = ctx->object.Get(ctx->env->GetIsolate()); 
  7.            Local<Value> cb; 
  8.            Local<Context> context = ctx->env->GetContext(); 
  9.            Local<String> onevent = newStringToLcal(ctx->env->GetIsolate(), event);        
  10.            object->Get(context, onevent).ToLocal(&cb); 
  11.            if (cb->IsFunction()) {   
  12.                Local<Value> argv[] = { 
  13.                    Integer::New(context->GetIsolate(), _req->res) 
  14.                }; 
  15.                // 执行JS层回调 
  16.                cb.As<v8::Function>()->Call(context, object, 1, argv); 
  17.            } 
  18.        } 
  19.    }; 

makeCallback做的事情就是执行JS回调。

4 非io_uring的处理

io_uring目前已经支持了非常多的操作，但我们也不可避免地会碰到io_uring不支持的操作，比如信号的处理。No里目前定时器和信号不是使用io_uring处理的。定时器目前使用内核的posix timer实现的，io_uring有个timeout类型的请求，可能会使用io_uring的，信号处理io_uring就无能无力了。因为No是单线程的架构，所以非io_uring的任务完成后也需要通过io_uring事件循环执行，下面看一下非io_uring支持的操作如何处理的。在业务里，我们可能需要监听一个信号。

  1. const { 
  2.     signal, 
  3.     console, 
  4.     process, 
  5.     timer,} = No; 
  6.  
  7. signal.on(signal.constant.SIG.SIGUSR1, () => { 
  8.     process.exit(); 
  9.  
  10. }); 
  11.  
  12. // for keep process alive 
  13.  
  14. timer.setInterval(() => {},10000, 10000); 

可以通过signal模块的on实现监听信号，接下来看看具体实现。

  1. void No::Signal::RegisterSignal(V8_ARGS) { 
  2.     V8_ISOLATE 
  3.     V8_CONTEXT 
  4.     Environment *env = Environment::GetEnvByContext(context); 
  5.     Local<Object> obj = Object::New(isolate); 
  6.     Local<String> key = newStringToLcal(isolate, onsignal); 
  7.     obj->Set(context, key, args[1].As<Function>()); 
  8.     int sig = args[0].As<Integer>()->Value();  
  9.     // 新建一个上下文 
  10.     shared_ptr<SignalRequestContext> ctx = make_shared<SignalRequestContext>(env, obj, sig); 
  11.     auto ret = signalMap.find(sig); 
  12.     // 是否在map里，不是则新建一个vector，否则直接追加 
  13.     if (ret == signalMap.end()) { 
  14.         signal(sig, signalHandler); 
  15.         vector<shared_ptr<SignalRequestContext>> vec; 
  16.         vec.push_back(ctx); 
  17.         signalMap.insert(map<int, vector<shared_ptr<SignalRequestContext>>>::value_type (sig, vec));   
  18.         return; 
  19.     } 
  20.     ret->second.push_back(ctx); 
  21.  
  22. } 

No使用一个map管理信号和监听函数，因为支持多个监听函数，所以map的key是信号的值，value是一个回调函数数组。如果是第一次注册该信号，则调用signal注册该信号的处理函数，所有信号的处理函数都是signalHandler。接着看信号产生时的处理逻辑。

  1. static void signalHandler(int signum){    
  2.     auto vec = signalMap.find(signum); 
  3.     if (vec != signalMap.end()) { 
  4.         vector<shared_ptr<SignalRequestContext>>::iterator it; 
  5.         for(it=vec->second.begin();it!=vec->second.end(); it++) 
  6.         { 
  7.             struct signal_request * req = (struct signal_request *)malloc(sizeof(*req));  
  8.             memset(req, 0, sizeof(*req)); 
  9.             req->cb = signal_cb; 
  10.             req->data = (void *)(*it).get(); 
  11.             req->op = IORING_OP_NOP; 
  12.             SubmitRequest((struct request *)req, (*it).get()->env->GetIOUringData()); 
  13.         } 
  14.     } 
  15.  
  16. } 

信号产生时，从map中找到对应的处理函数列表，然后生成一个io_uring请求，这样在事件循环时就会被执行，也实现了非io_uring任务和io_uring任务的整合，这里主要是利用了io_uring提供了nop类型的请求，这个类型的请求不做任何操作，主要是用于测试io_uring请求和响应链路，利用这点恰好可以实现我们的需求。从代码中可以看到io_uring事件循环时会执行信号处理的回调signal_cb，signal_cb会回调JS层。

5 上下文的设计

因为No各种请求都是异步的，所以避免不了需要保持请求和响应的上下文。类似Node.js，No里也存在一个env作为整个进程级的上下文。

  1. enum { 
  2.     CONTEXT_INDEX 
  3. } ENV_INDEX; 
  4.  
  5. class Environment { 
  6.     public: 
  7.         Environment(Local<Context> context); 
  8.         static Environment * GetEnvByContext(Local<Context> context); 
  9.         struct io_uring_info * GetIOUringData() { 
  10.             return io_uring_data; 
  11.         } 
  12.         Isolate * GetIsolate() const { 
  13.             return _isolate; 
  14.         } 
  15.          Local<Context> GetContext() const { 
  16.             return PersistentToLocal::Strong(_context); 
  17.         } 
  18.     private: 
  19.         struct io_uring_info *io_uring_data; 
  20.         Global<Context> _context; 
  21.         Isolate * _isolate; 
  22.  
  23. }; 

env目前的功能还不多，只要负责管理context、isolate、io_uring等数据结构。另外还有一些和具体操作相关的上下文。

  1. struct RequestContext { 
  2.    RequestContext(Environment * passEnv, Local<Object> _object) 
  3.    : env(passEnv),  object(passEnv->GetIsolate(), _object) {} 
  4.    ~RequestContext() { 
  5.        if (!object.IsEmpty()) { 
  6.            object.Reset(); 
  7.        } 
  8.    } 
  9.    Environment * env; 
  10.    Global<Object> object; 
  11.  
  12. }; 
  13.  
  14.  
  15.  
  16. struct SignalRequestContext: public RequestContext 
  17.  
  18. { 
  19.    SignalRequestContext(Environment * passEnv, Local<Object> _object, int _sig) 
  20.    : RequestContext(passEnv, _object), sig(_sig) {} 
  21.    int sig; 
  22.  
  23. }; 

前面介绍过io_uring层的上下文request，request主要是用于io_uring任务完成时，知道执行哪个回调函数，并且记录了少量的上下文，但是reuqest的字段不一定够用，所以RequestContext主要记录额外的上下文，其实把RequestContext的字段合进request也是可以的。

6 事件循环的设计

No的事件循环是io_uring实现的，事件循环的本质就是在一个循环里不断等待任务和执行任务，那么什么时候结束呢?

  1. while(io_uring_data->stop != 1 && io_uring_data->pending != 0) { 
  2.         // 等待和处理任务 
  3.  
  4. } 

目前可以通过设置stop直接停止事件循环，正常情况下，没有任务了就会结束事件循环，通过pending字段记录，比如发起一个读取文件的请求，pending就是1，读完后就会减一，这时候，事件循环就会结束，相对Node.js的handle和request，No里是没有的，No里通过控制pending的值去控制事件循环的状态。

7 如何使用

No是基于Linux的io_uring的，目前在Linux5.5及以上的系统可以运行，可以安装ubuntu21.04及以上的虚拟机使用，具体可以参考仓库说明(https://github.com/theanarkh/No.js)。目前支持了TCP、UCP、Unix域、文件、信号、定时器、log，进程还没有写完，总体只是支持一些简单的操作，后续慢慢更新。

8 后记

写No是一个让人非常深刻的过程，已经很多年没有正经写过c、c++代码，或许代码里有不对的用法，但是整个过程里的思考、编码和调试让我学到了很多东西，也给我了一段深刻的时光。目前实现的功能还不多，也不足以用起来，还有很多事情需要做，纸上得来终觉浅，绝知此事要躬行。后续慢慢学习、慢慢思考、慢慢更新!

原文链接：https://mp.weixin.qq.com/s/uUfoQ4nJjKgu9BVMbjzRag

标签：
JS No.js io_uring 

相关文章

热门资讯

yue是什么意思 网络流行语yue了是什么梗
yue是什么意思 网络流行语yue了是什么梗 2020-10-11
2020微信伤感网名听哭了 让对方看到心疼的伤感网名大全
2020微信伤感网名听哭了 让对方看到心疼的伤感网名大全 2019-12-26
背刺什么意思 网络词语背刺是什么梗
背刺什么意思 网络词语背刺是什么梗 2020-05-22
苹果12mini价格表官网报价 iPhone12mini全版本价格汇总
苹果12mini价格表官网报价 iPhone12mini全版本价格汇总 2020-11-13
2021年耽改剧名单 2021要播出的59部耽改剧列表
2021年耽改剧名单 2021要播出的59部耽改剧列表 2021-03-05
返回顶部