Reputation: 4323
I'm interested in performance comparison of synchronous and asynchronous data conversion test in case if async function would return result immediately. Will this affect on execution time?
To check this, I wrote simple bench to check.
const { performance } = require('perf_hooks');
const data = JSON.stringify((() => {
const obj = {};
for (let i = 0; i < 1000; i++) {
obj[i] = i;
}
return obj;
})());
function convertSync (data) {
return JSON.parse(data);
}
async function convertAsync (data) {
return JSON.parse(data);
}
const REPEAT_COUNT = 10000;
performance.mark("sync_start");
for (let i = 0; i < REPEAT_COUNT; i++) {
convertSync(data);
}
performance.mark("sync_end");
performance.mark("async_start");
Promise.resolve()
.then(async () => {
for (let i = 0; i < REPEAT_COUNT; i++) {
await convertAsync(data);
}
performance.mark("async_end");
})
.then(async () => {
performance.measure("sync", "sync_start", "sync_end");
performance.measure("async", "async_start", "async_end");
console.log("REPEAT_COUNT", REPEAT_COUNT);
console.log(performance.getEntries().filter(x => x.entryType === "measure"));
})
I'm using Node v8.11.1 without any transpilers and getting following results.
PS D:\TestProjects\PerfTest\promisevssync> node .\index.js
REPEAT_COUNT 100000
[ PerformanceEntry {
duration: 7825.5724,
startTime: 383379071.208899,
entryType: 'measure',
name: 'sync' },
PerformanceEntry {
duration: 7836.966301,
startTime: 383386896.834899,
entryType: 'measure',
name: 'async' } ]
PS D:\TestProjects\PerfTest\promisevssync> node .\index.js
REPEAT_COUNT 10000
[ PerformanceEntry {
duration: 788.824201,
startTime: 383405055.485299,
entryType: 'measure',
name: 'sync' },
PerformanceEntry {
duration: 798.591301,
startTime: 383405844.370999,
entryType: 'measure',
name: 'async' } ]
As you can see execution time is the same. For higher repeat count numbers are still not differs much, so I believe that this is just a nose. Such results raises two questions:
I understand that I missing something, but it seems that I forgot to take some fundamental thing in to account.
Upvotes: 0
Views: 197
Reputation: 223318
I'm interested in performance comparison of synchronous and asynchronous data conversion test in case if async function would return result immediately. Will this affect on execution time?
The measurements are correct but notice that what's measured is the performance of synchronous and asynchronous iteration, while data conversion stays synchronous.
Node.js has high-resolution timer, so promises themselves introduce only a slight lag
that is negligible in comparison with time spent on convertAsync
call.
This test with 10000 iterations confirms this:
for (let i = 0; i < REPEAT_COUNT; i++) {}
vs
for (let i = 0; i < REPEAT_COUNT; i++) {
await null;
}
The measurements are 0.5ms for synchronous loop vs 9ms for asynchronous.
In contrast with a dry run, most of the time will be spent on JSON.parse(data)
.
Upvotes: 2
Reputation: 2646
For async-await to work your function should return a promise which is not the case. So you are getting similar results since convertAsync is not truly async function. Internally what javascript does is wrap your function in resolved promise and since your promise is almost immediately resolved you see minimal diff in your results.
Take a look at https://javascript.info/async-await
Upvotes: 2