Rhino 会像 Node.js 那样自动优化脚本吗?
Does Rhino auto-optimize scripts like how Node.js does?
我想测试搜索文本的不同方法及其对时间的影响。
为此,我写了这个:
// test case 1: no regex instance & regex.exec
let t1total = 0;
for (let j = 0; j < trialCount; j++){
let start = performance.now();
for (let i = 0; i < splitLog.length; i++) {
/^([A-Z]+)[^\d]+([\d\/\-.:]+\sUTC)/.exec(splitLog[i]);
}
let end = performance.now();
t1total += end - start
}
t1total /= trialCount;
// test case 2: pre-compile + regex.exec
let t2total = 0;
let compileStart = performance.now();
const preRegex = new RegExp(/^([A-Z]+)[^\d]+([\d\/\-.:]+\sUTC)/);
let compileEnd = performance.now();
t2total += compileEnd - compileStart;
for (let j = 0; j < trialCount; j++){
let start = performance.now();
for (let i = 0; i < splitLog.length; i++) {
preRegex.exec(splitLog[i]);
}
let end = performance.now();
t2total += end - start
}
t2total /= trialCount;
我想 运行 经过多次试验并取平均值以获得更一致的结果,但意识到节点会自动优化这种情况。
1 次试验的结果(毫秒):
Test 1: no regex instance + regex.exec 9.151600003242493
Test 2: pre-compile + regex.exec 4.707100033760071
1000 次试验的结果(毫秒):
Test 1: no regex instance + regex.exec 2.340533686041832
Test 2: pre-compile + regex.exec 2.199146592259407
因此,当重复创建相同的正则表达式时,节点将对自身进行此优化。
现在假设有一个脚本,其中 exec 在尚未实例化的正则表达式上仅被调用一次。 Rhino 是否会重复调用这样的脚本对节点 运行ning 循环如测试用例 1 进行类似的优化?
换句话说,Rhino是否优化了重复调用实例化正则表达式的脚本,类似于nodejs如何优化重复实例化相同的正则表达式?
我 运行 进行了一些测试来尝试解决这个问题,似乎确实存在类似的自动优化,但这是不同方法之间的显着差异 - 与我使用 Node.js 的结果不同。
Trials : 1
Lines: 35629
Regex compile time: 111859500
no instance + exec: 196013300
precompile + exec: 127519700
no instance + match: 116066300
precompile + match: 68303500
~~~~~~~~~~~~~~~~~~~~~~~~~~~
Trials: 1000
Lines: 35629
Regex compile time: 99829400
no instance + exec: 40101506
precompile + exec: 37426255
no instance + match: 45371233
precompile + match: 44917744
最重要的是运行我的结果似乎确实会根据运行 的试验次数发生显着变化。此外,re-instantiating 脚本似乎会中断此优化。可以找到完整的结果 here。
我创建了一个 "precompiled" 正则表达式,方法是在脚本中编译一个正则表达式,然后将其拉出到一个 java 对象中。然后我会将该对象作为参数传递给需要已经编译的正则表达式来进行搜索的脚本。
注意:结果仅对 运行 搜索的脚本计时,不包括 创建 正则表达式或脚本本身的时间。
我想测试搜索文本的不同方法及其对时间的影响。 为此,我写了这个:
// test case 1: no regex instance & regex.exec
let t1total = 0;
for (let j = 0; j < trialCount; j++){
let start = performance.now();
for (let i = 0; i < splitLog.length; i++) {
/^([A-Z]+)[^\d]+([\d\/\-.:]+\sUTC)/.exec(splitLog[i]);
}
let end = performance.now();
t1total += end - start
}
t1total /= trialCount;
// test case 2: pre-compile + regex.exec
let t2total = 0;
let compileStart = performance.now();
const preRegex = new RegExp(/^([A-Z]+)[^\d]+([\d\/\-.:]+\sUTC)/);
let compileEnd = performance.now();
t2total += compileEnd - compileStart;
for (let j = 0; j < trialCount; j++){
let start = performance.now();
for (let i = 0; i < splitLog.length; i++) {
preRegex.exec(splitLog[i]);
}
let end = performance.now();
t2total += end - start
}
t2total /= trialCount;
我想 运行 经过多次试验并取平均值以获得更一致的结果,但意识到节点会自动优化这种情况。
1 次试验的结果(毫秒):
Test 1: no regex instance + regex.exec 9.151600003242493
Test 2: pre-compile + regex.exec 4.707100033760071
1000 次试验的结果(毫秒):
Test 1: no regex instance + regex.exec 2.340533686041832
Test 2: pre-compile + regex.exec 2.199146592259407
因此,当重复创建相同的正则表达式时,节点将对自身进行此优化。
现在假设有一个脚本,其中 exec 在尚未实例化的正则表达式上仅被调用一次。 Rhino 是否会重复调用这样的脚本对节点 运行ning 循环如测试用例 1 进行类似的优化?
换句话说,Rhino是否优化了重复调用实例化正则表达式的脚本,类似于nodejs如何优化重复实例化相同的正则表达式?
我 运行 进行了一些测试来尝试解决这个问题,似乎确实存在类似的自动优化,但这是不同方法之间的显着差异 - 与我使用 Node.js 的结果不同。
Trials : 1
Lines: 35629
Regex compile time: 111859500
no instance + exec: 196013300
precompile + exec: 127519700
no instance + match: 116066300
precompile + match: 68303500
~~~~~~~~~~~~~~~~~~~~~~~~~~~
Trials: 1000
Lines: 35629
Regex compile time: 99829400
no instance + exec: 40101506
precompile + exec: 37426255
no instance + match: 45371233
precompile + match: 44917744
最重要的是运行我的结果似乎确实会根据运行 的试验次数发生显着变化。此外,re-instantiating 脚本似乎会中断此优化。可以找到完整的结果 here。
我创建了一个 "precompiled" 正则表达式,方法是在脚本中编译一个正则表达式,然后将其拉出到一个 java 对象中。然后我会将该对象作为参数传递给需要已经编译的正则表达式来进行搜索的脚本。
注意:结果仅对 运行 搜索的脚本计时,不包括 创建 正则表达式或脚本本身的时间。