一、JavaScript

1.JavaScript语言

JavaScript是ECMAScript的实现,由ECMA 39(欧洲计算机制造商协会39号技术委员会)负责制定ECMAScript标准。

ECMAScript发展史:

2.JavaScript引擎

JavaScript引擎是指用于处理以及执行JavaScript脚本的虚拟机。

常见的JavaScript引擎:







3.JavaScript引擎工作原理

a.V8引擎工作原理





b.Turbofan技术实例说明

1function sum(a, b) {
2    return a + b;
3}

这里a和b可以是任意类型数据，当执行sum函数时，Ignition解释器会检查a和b的数据类型，并相应地执行加法或者连接字符串的操作。

如果 sum函数被调用多次，每次执行时都要检查参数的数据类型是很浪费时间的。此时TurboFan就出场了。它会分析函数的执行信息，如果以前每次调用sum函数时传递的参数类型都是数字，那么TurboFan就预设sum的参数类型是数字类型，然后将其编译为机器码。

但是如果某一次的调用传入的参数不再是数字时，表示TurboFan的假设是错误的，此时优化编译生成的机器代码就不能再使用了，于是就需要进行回退到字节码的操作。



三、QuickJS

1.QuickJS作者简介

法布里斯·貝拉 (Fabrice Bellard)









2.QuickJS简介

QuickJS 是一个小型的嵌入式 Javascript 引擎。 它支持 ES2023 规范，包括模块、异步生成器、代理和 BigInt。

它可以选择支持数学扩展，例如大十进制浮点数 (BigDecimal)、大二进制浮点数 (BigFloat) 和运算符重载。

•小且易于嵌入：只需几个 C 文件，无外部依赖项，一个简单的 hello world 程序的 210 KiB x86 代码。

•启动时间极短的快速解释器：在台式 PC 的单核上运行 ECMAScript 测试套件的 76000 次测试只需不到 2 分钟。 运行时实例的完整生命周期在不到 300 微秒的时间内完成。

•几乎完整的 ES2023 支持，包括模块、异步生成器和完整的附录 B 支持（旧版 Web 兼容性）。

•通过了近 100% 的 ECMAScript 测试套件测试: Test262 Report(https://test262.fyi/#)。

•可以将 Javascript 源代码编译为可执行文件，无需外部依赖。

•使用引用计数（以减少内存使用并具有确定性行为）和循环删除的垃圾收集。

•数学扩展：BigDecimal、BigFloat、运算符重载、bigint 模式、数学模式。

•用 Javascript 实现的带有上下文着色的命令行解释器。

•带有 C 库包装器的小型内置标准库。

3.QuickJS工程简介

15.94MB quickjs
2├── 17.6kB      cutils.c                /// 辅助函数
3├── 7.58kB      cutils.h                /// 辅助函数
4├── 241kB       libbf.c                 /// BigFloat相关
5├── 17.9kB      libbf.h                 /// BigFloat相关
6├── 2.25kB      libregexp-opcode.h      /// 正则表达式操作符
7├── 82.3kB      libregexp.c             /// 正则表达式相关
8├── 3.26kB      libregexp.h             /// 正则表达式相关
9├── 3.09kB      list.h                  /// 链表实现
10├── 16.7kB      qjs.c                   /// QuickJS stand alone interpreter
11├── 22kB        qjsc.c                  /// QuickJS command line compiler
12├── 73.1kB      qjscalc.js              /// 数学计算器
13├── 7.97kB      quickjs-atom.h          /// 定义了javascript中的关键字
14├── 114kB       quickjs-libc.c
15├── 2.57kB      quickjs-libc.h          /// C API
16├── 15.9kB      quickjs-opcode.h        /// 字节码操作符定义
17├── 1.81MB      quickjs.c               
18├── 41.9kB      quickjs.h               /// QuickJS Engine
19├── 49.8kB      repl.js                 /// REPL
20├── 218kB       libunicode-table.h      /// unicode相关
21├── 53kB        libunicode.c            /// unicode相关
22├── 3.86kB      libunicode.h            /// unicode相关
23├── 86.4kB      unicode_gen.c           /// unicode相关
24└── 6.99kB      unicode_gen_def.h       /// unicode相关

4.QuickJS工作原理

QuickJS的解释器是基于栈的。





QuickJS的对byte-code会优化两次,通过一个简单例子看看QuickJS的字节码与优化器的输出,以及执行过程。

1function sum(a, b) {
2    return a + b;
3}

•第一阶段(未经过优化的字节码)

1;; function sum(a, b) {
2
3        enter_scope 1    
4
5;;     return a + b;
6
7        line_num 2
8        scope_get_var a,1    ///通用的获取变量的指令
9        scope_get_var b,1    
10        add
11        return
12
13;; }

•第二阶段

1;; function sum(a, b) {
2;;     return a + b;
3
4        line_num 2
5        get_arg 0: a        /// 获取参数列表中的变量
6        get_arg 1: b
7        add
8        return
9;; }

•第三阶段

1;; function sum(a, b) {
2;;     return a + b;
3
4        get_arg0 0: a        /// 精简成获取参数列表中第0个参数
5        get_arg1 1: b
6        add
7        return
8
9;; }

sum(1,2);

通过上述简单的函数调用,观察sum函数调用过程中栈帧的变化,通过计算可知sum函数最栈帧大小为两个字节

5.内存管理

QuickJS通过引用计算来管理内存,在使用C API时需要根据不同API的说明手动增加或者减少引用计数器。

对于循环引用的对象,QuickJS通过临时减引用保存到临时数组中的方法来判断相互引用的对象是否可以回收。

6.QuickJS简单使用

从github上clone完最新的源码后,通过执行(macos 环境)以下代码即可在本地安装好qjs、qjsc、qjscalc几个命令行程序

1sudo make
2sudo make install

•qjs: JavaScript代码解释器

•qjsc: JavaScript代码编译器

•qjscalc: 基于QuickJS的REPL计算器程序

通过使用qjs可以直接运行一个JavaScript源码,通过qsjc的如下命令,则可以输出一个带有byte-code源码的可直接运行的C源文件:

qjsc -e  -o add.c examples/add.js 

1#include "quickjs-libc.h"
2
3const uint32_t qjsc_add_size = 135;
4
5const uint8_t qjsc_add[135] = {
6 0x02, 0x06, 0x06, 0x73, 0x75, 0x6d, 0x0e, 0x63,
7 0x6f, 0x6e, 0x73, 0x6f, 0x6c, 0x65, 0x06, 0x6c,
8 0x6f, 0x67, 0x1e, 0x65, 0x78, 0x61, 0x6d, 0x70,
9 0x6c, 0x65, 0x73, 0x2f, 0x61, 0x64, 0x64, 0x2e,
10 0x6a, 0x73, 0x02, 0x61, 0x02, 0x62, 0x0e, 0x00,
11 0x06, 0x00, 0xa2, 0x01, 0x00, 0x01, 0x00, 0x05,
12 0x00, 0x01, 0x25, 0x01, 0xa4, 0x01, 0x00, 0x00,
13 0x00, 0x3f, 0xe3, 0x00, 0x00, 0x00, 0x40, 0xc2,
14 0x00, 0x40, 0xe3, 0x00, 0x00, 0x00, 0x00, 0x38,
15 0xe4, 0x00, 0x00, 0x00, 0x42, 0xe5, 0x00, 0x00,
16 0x00, 0x38, 0xe3, 0x00, 0x00, 0x00, 0xb8, 0xb9,
17 0xf2, 0x24, 0x01, 0x00, 0xcf, 0x28, 0xcc, 0x03,
18 0x01, 0x04, 0x1f, 0x00, 0x08, 0x0a, 0x0e, 0x43,
19 0x06, 0x00, 0xc6, 0x03, 0x02, 0x00, 0x02, 0x02,
20 0x00, 0x00, 0x04, 0x02, 0xce, 0x03, 0x00, 0x01,
21 0x00, 0xd0, 0x03, 0x00, 0x01, 0x00, 0xd3, 0xd4,
22 0x9e, 0x28, 0xcc, 0x03, 0x01, 0x01, 0x03,
23};
24
25static JSContext *JS_NewCustomContext(JSRuntime *rt)
26{
27  JSContext *ctx = JS_NewContextRaw(rt);
28  if (!ctx)
29    return NULL;
30  JS_AddIntrinsicBaseObjects(ctx);
31  JS_AddIntrinsicDate(ctx);
32  JS_AddIntrinsicEval(ctx);
33  JS_AddIntrinsicStringNormalize(ctx);
34  JS_AddIntrinsicRegExp(ctx);
35  JS_AddIntrinsicJSON(ctx);
36  JS_AddIntrinsicProxy(ctx);
37  JS_AddIntrinsicMapSet(ctx);
38  JS_AddIntrinsicTypedArrays(ctx);
39  JS_AddIntrinsicPromise(ctx);
40  JS_AddIntrinsicBigInt(ctx);
41  return ctx;
42}
43
44int main(int argc, char **argv)
45{
46  JSRuntime *rt;
47  JSContext *ctx;
48  rt = JS_NewRuntime();
49  js_std_set_worker_new_context_func(JS_NewCustomContext);
50  js_std_init_handlers(rt);
51  JS_SetModuleLoaderFunc(rt, NULL, js_module_loader, NULL);
52  ctx = JS_NewCustomContext(rt);
53  js_std_add_helpers(ctx, argc, argv);
54  js_std_eval_binary(ctx, qjsc_add, qjsc_add_size, 0);
55  js_std_loop(ctx);
56  js_std_free_handlers(rt);
57  JS_FreeContext(ctx);
58  JS_FreeRuntime(rt);
59  return 0;
60}

上面的这个C源文件，通过如下命令即可编译成可执行文件:

 gcc add.c -o add_exec -I/usr/local/include quickjs-libc.c quickjs.c cutils.c libbf.c libregexp.c libunicode.c  -DCONFIG_BIGNUM

也可以直接使用如下命令,将JavaScript文件直接编译成可执行文件:

qjsc -o add_exec examples/add.js

7.给qjsc添加扩展

QuickJS只实现了最基本的JavaScript能力，同时QuickJS也可以实现能力的扩展，比如给QuickJS添加打开文件并读取文件内容的内容,这样在JavaScript代码中即可通过js代码打开并读取到文件内容了。

通过一个例子来看看添加扩展都需要做哪些操作:

•编写一个C语言的扩展模块

1#include "quickjs.h"
2#include "cutils.h"
3
4/// js中对应plus函数的C语言函数
5static JSValue plusNumbers(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
6    int a, b;
7    if (JS_ToInt32(ctx, &a, argv[0]))
8        return JS_EXCEPTION;
9    if (JS_ToInt32(ctx, &b, argv[1]))
10        return JS_EXCEPTION;
11    return JS_NewInt32(ctx, a + b);
12}
13/// 模块需要导致的列表
14static const JSCFunctionListEntry js_my_module_funcs[] = {
15    JS_CFUNC_DEF("plus", 2, plusNumbers),
16};
17/// 模块初始化函数,并将plus导出
18static int js_my_module_init(JSContext *ctx, JSModuleDef *m) {
19    return JS_SetModuleExportList(ctx, m, js_my_module_funcs, countof(js_my_module_funcs));
20}
21JSModuleDef *js_init_module_my_module(JSContext *ctx, const char *module_name) {
22    JSModuleDef *m;
23    m = JS_NewCModule(ctx, module_name, js_my_module_init);
24    if (!m)
25        return NULL;
26    JS_AddModuleExportList(ctx, m, js_my_module_funcs, countof(js_my_module_funcs));
27    return m;
28}

•Makefile文件中添加my_module.c模块的编译

QJS_LIB_OBJS= ... $(OBJDIR)/my_module.o

•在qjsc.c文件中注册模块

namelist_add（＆cmodule_list，“my_module”，“my_module”，0）; 

•编写一个my_module.js测试文件

1import * as mm from 'my_module';
2
3const value = mm.plus(1, 2);
4console.log(`my_module.plus: ${value}`);

•重新编译

1sudo make && sudo make install
2qjsc -m -o my_module examples/my_module.js /// 这里需要指定my_module模块

最终生成的my_module可执行文件,通过执行my_module输出:

my_module.plus: 3

8.使用C API

在第5个步骤时,生成了add.c文件中实际上已经给出了一个简单的使用C API最基本的代码。当编写一下如下的js源码时,会发现当前的qjsc编译后的可执行文件或者qjs执行这段js代码与我们的预期不符:

1function getName() {
2    return new Promise((resolve, reject) => {
3        setTimeout(() => {
4            resolve("张三峰");
5        }, 2000);
6    });
7}
8console.log(`开始执行`);
9getName().then(name => console.log(`promise name: ${name}`));







上面的代码并不会按预期的效果输出结果,因为js环境下的loop只执行了一次,任务队列还没有来得急执行程序就结束了,稍微改动一下让程序可以正常输出,如下：

1#include <stdio.h>
2#include <pthread.h>
3#include <stdlib.h>
4#include <uv.h>
5/* File generated automatically by the QuickJS compiler. */
6
7#include "quickjs-libc.h"
8#include <string.h>
9
10
11
12static JSContext *JS_NewCustomContext(JSRuntime *rt) {
13  JSContext *ctx = JS_NewContextRaw(rt);
14  if (!ctx)
15    return NULL;
16  JS_AddIntrinsicBaseObjects(ctx);
17  JS_AddIntrinsicDate(ctx);
18  JS_AddIntrinsicEval(ctx);
19  JS_AddIntrinsicStringNormalize(ctx);
20  JS_AddIntrinsicRegExp(ctx);
21  JS_AddIntrinsicJSON(ctx);
22  JS_AddIntrinsicProxy(ctx);
23  JS_AddIntrinsicMapSet(ctx);
24  JS_AddIntrinsicTypedArrays(ctx);
25  JS_AddIntrinsicPromise(ctx);
26  JS_AddIntrinsicBigInt(ctx);
27  return ctx;
28}
29
30JSRuntime *rt = NULL;
31JSContext *ctx = NULL;
32void *run(void *args) {
33    const char *file_path = "/Volumes/Work/分享/quickjs/code/quickjs/examples/promise.js";
34    size_t pbuf_len = 0;
35    
36    
37    js_std_set_worker_new_context_func(JS_NewCustomContext);
38    js_std_init_handlers(rt);
39    JS_SetModuleLoaderFunc(rt, NULL, js_module_loader, NULL);
40    ctx = JS_NewCustomContext(rt);
41    
42    
43    js_std_add_helpers(ctx, 0, NULL);
44    js_init_module_os(ctx, "test");
45    const uint8_t *code = js_load_file(ctx, &pbuf_len, file_path);
46    JSValue js_ret_val = JS_Eval(ctx, (char *)code, pbuf_len, "add", JS_EVAL_TYPE_MODULE);
47    if(JS_IsError(ctx, js_ret_val) || JS_IsException(js_ret_val)) {
48        js_std_dump_error(ctx);
49    }
50    return NULL;
51}
52
53pthread_t quickjs_t;
54int main(int argc, char **argv) {
55    rt = JS_NewRuntime();
56    pthread_create(&quickjs_t, NULL, run, NULL);
57    while (1) {
58        if(ctx) js_std_loop(ctx);
59    }
60    js_std_free_handlers(rt);
61    JS_FreeContext(ctx);
62    JS_FreeRuntime(rt);
63    return 0;
64}

这样的操作只适合用于测试一下功能,实际生产中使用需要一个即可以在必要的时候调用loop又可以做到不抢占过多的CPU或者只抢占较少的CPU时间片。



四、libuv

1.libuv简价

libuv 是一个使用C语言编写的多平台支持库，专注于异步 I/O。 它主要是为 Node.js 使用而开发的，但 Luvit、Julia、uvloop 等也使用它。

功能亮点

•由 epoll、kqueue、IOCP、事件端口支持的全功能事件循环。

•异步 TCP 和 UDP 套接字

•异步 DNS 解析

•异步文件和文件系统操作

•文件系统事件

•ANSI 转义码控制的 TTY

•具有套接字共享的 IPC，使用 Unix 域套接字或命名管道 (Windows)

•子进程

•线程池

•信号处理

•高分辨率时钟

•线程和同步原语

2.libuv运行原理









1int uv_run(uv_loop_t* loop, uv_run_mode mode) {
2  ...
3  r = uv__loop_alive(loop);
4  if (!r)
5    uv__update_time(loop);
6  while (r != 0 && loop->stop_flag == 0) {
7    uv__update_time(loop);
8    uv__run_timers(loop);
9    ran_pending = uv__run_pending(loop);
10    uv__run_idle(loop);
11    uv__run_prepare(loop);
12    ...
13    uv__io_poll(loop, timeout);
14    uv__run_check(loop);
15    uv__run_closing_handles(loop);
16    ...
17  }
18}

3.简单使用

1static void timer_cb(uv_timer_t *handler) {
2    printf("timer_cb exec.\r\n");
3}
4
5int main(int argc, const char * argv[]) {
6   uv_loop_t *loop = uv_default_loop();
7   uv_timer_t *timer = (uv_timer_t*)malloc(sizeof(uv_timer_t));
8   uv_timer_init(loop, timer);
9   uv_timer_start(timer, timer_cb, 2000, 0);
10   uv_run(loop, UV_RUN_DEFAULT);
11}

五、QuickJS + libuv

1console.log(`开始执行`);
2function getName() {
3    return new Promise((resolve, reject) => {
4        setTimeout(() => {
5            resolve("张三峰");
6        }, 2000);
7    });
8}
9getName().then(name => console.log(`promise name: ${name}`));







1#include <stdio.h>
2#include <pthread.h>
3#include <stdlib.h>
4#include <uv.h>
5/* File generated automatically by the QuickJS compiler. */
6
7#include "quickjs-libc.h"
8#include <string.h>
9
10
11typedef struct once_timer_data {
12    JSValue func;
13    JSValue this_val;
14    JSContext *ctx;
15} once_timer_data;
16
17void once_timer_cb(uv_timer_t *once_timer) {
18    once_timer_data *data = (once_timer_data *)once_timer->data;
19    JSContext *ctx = data->ctx;
20    JSValue js_ret_val = JS_Call(data->ctx, data->func, data->this_val, 0, NULL);
21    if(JS_IsError(ctx, js_ret_val) || JS_IsException(js_ret_val)) {
22        js_std_dump_error(ctx);
23    }
24    JS_FreeValue(data->ctx, js_ret_val);
25    JS_FreeValue(data->ctx, data->func);
26    JS_FreeValue(data->ctx, data->this_val);
27    free(data);
28    uv_timer_stop(once_timer);
29    free(once_timer);
30}
31
32void check_cb(uv_check_t *check) {
33    JSContext *ctx = (JSContext *)check->data;
34    js_std_loop(ctx);
35}
36void idle_cb(uv_idle_t *idle) {
37    
38}
39
40
41JSValue set_timeout(JSContext *ctx, JSValue this_val, int argc, JSValue *argv) {
42 
43    if(argc != 2) return JS_NULL;
44    JSValue func_val = argv[0];
45    JSValue delay_val = argv[1];
46    int64_t delay = 0;
47    int ret = JS_ToInt64(ctx, &delay, delay_val);
48    if(ret < 0) js_std_dump_error(ctx);
49    uv_timer_t *once_timer = (uv_timer_t *)malloc(sizeof(uv_timer_t));
50    once_timer_data *data = (once_timer_data *)malloc(sizeof(once_timer_data));
51    data->func = JS_DupValue(ctx, func_val);
52    data->this_val = JS_DupValue(ctx, this_val);
53    data->ctx = ctx;
54    once_timer->data = data;
55    uv_timer_init(uv_default_loop(), once_timer);
56    uv_timer_start(once_timer, once_timer_cb, delay, 0);
57    JSValue js_timer = JS_NewInt64(ctx, (uint64_t)once_timer);
58    return js_timer;
59}
60
61
62
63static JSContext *JS_NewCustomContext(JSRuntime *rt) {
64  JSContext *ctx = JS_NewContextRaw(rt);
65  if (!ctx)
66    return NULL;
67  JS_AddIntrinsicBaseObjects(ctx);
68  JS_AddIntrinsicDate(ctx);
69  JS_AddIntrinsicEval(ctx);
70  JS_AddIntrinsicStringNormalize(ctx);
71  JS_AddIntrinsicRegExp(ctx);
72  JS_AddIntrinsicJSON(ctx);
73  JS_AddIntrinsicProxy(ctx);
74  JS_AddIntrinsicMapSet(ctx);
75  JS_AddIntrinsicTypedArrays(ctx);
76  JS_AddIntrinsicPromise(ctx);
77  JS_AddIntrinsicBigInt(ctx);
78  return ctx;
79}
80
81
82void js_job(uv_timer_t *timer) {
83    JSRuntime *rt = timer->data;
84    const char *file_path = "/Volumes/Work/分享/quickjs/code/quickjs/examples/promise.js";
85    size_t pbuf_len = 0;
86    
87    JSContext *ctx;
88    js_std_set_worker_new_context_func(JS_NewCustomContext);
89    js_std_init_handlers(rt);
90    JS_SetModuleLoaderFunc(rt, NULL, js_module_loader, NULL);
91    ctx = JS_NewCustomContext(rt);
92    
93    uv_check_t *check = (uv_check_t *)malloc(sizeof(uv_check_t));
94    uv_check_init(uv_default_loop(), check);
95    check->data = ctx;
96    uv_check_start(check, check_cb);
97    
98    JSValue global = JS_GetGlobalObject(ctx);
99    JSValue func_val = JS_NewCFunction(ctx, set_timeout, "setTimeout", 1);
100    JS_SetPropertyStr(ctx, global, "setTimeout", func_val);
101    JS_FreeValue(ctx, global);
102    
103    
104    js_std_add_helpers(ctx, 0, NULL);
105    js_init_module_os(ctx, "test");
106    const uint8_t *code = js_load_file(ctx, &pbuf_len, file_path);
107    JSValue js_ret_val = JS_Eval(ctx, (char *)code, pbuf_len, "add", JS_EVAL_TYPE_MODULE);
108    if(JS_IsError(ctx, js_ret_val) || JS_IsException(js_ret_val)) {
109        js_std_dump_error(ctx);
110    }
111    js_std_free_handlers(rt);
112    JS_FreeContext(ctx);
113  
114}
115
116
117int main(int argc, char **argv) {
118    JSRuntime *rt = JS_NewRuntime();
119    uv_loop_t *loop = uv_default_loop();
120    
121    uv_timer_t *timer = (uv_timer_t*)malloc(sizeof(uv_timer_t));
122    timer->data = rt;
123    uv_timer_init(loop, timer);
124    uv_timer_start(timer, js_job, 0, 0);
125    
126    uv_idle_t *idle = (uv_idle_t *)malloc(sizeof(uv_idle_t));
127    uv_idle_init(loop, idle);
128    uv_idle_start(idle, idle_cb);
129
130    uv_run(loop, UV_RUN_DEFAULT);
131    JS_FreeRuntime(rt);
132    return 0;
133}