Toggle navigation
MeasureThat.net
Create a benchmark
Tools
Feedback
FAQ
Register
Log In
Stack strategies
(version: 0)
Comparing performance of:
generators vs Manual
Created:
9 years ago
by:
Guest
Jump to the latest result
Tests:
generators
var GAS = 0; function run(init, makeGen) { GAS = init; var gen = makeGen(); while(true) { var res = gen.next(); if(res.done) { return res.value; } else { GAS = init; continue; } } } var linkNames = ["first", "rest"]; function link(f, r) { return { $name: "link", $fields: linkNames, first: f, rest: r } } var empty = { $name: "empty" }; function* map(f, l) { if(GAS-- <= 0) { yield null; } var ans; var dispatch = { empty: 0, link: 1 }; var case_step = dispatch[l.$name]; switch(case_step) { case 0: ans = empty break; case 1: fst = l[l.$fields[0]]; rst = l[l.$fields[1]]; var t1 = yield* f(fst); var t2 = yield* map(f, rst); var t3 = link(t1, t2); ans = t3; } return ans; } var buildList = function(n) { var l = empty; for(var i = 0; i < n; i++) { l = link(i, l).next().value; } return l; } run(100, function*() { return yield* map(function*(l) { return l + 1; }, buildList(4000)); });
Manual
var GAS = 0; function run(init, runner) { GAS = init; var frames = [{ run: runner }]; var thisFrame = frames.pop(); while(true) { var res = thisFrame.run(thisFrame); if(res.isCont) { var len = res.frames.length; for(var i = 0; i < len; i++) { frames.push(res.frames.pop()); } GAS = init; thisFrame = frames.pop(); } else { if(frames.length <= 0) { break; } thisFrame = frames.pop(); thisFrame.ans = res; } } return res; } var linkNames = ["first", "rest"]; function link(f, r) { return { $name: "link", $fields: linkNames, first: f, rest: r } } var empty = { $name: "empty" }; function map(f, l) { var step = 0; if(f.isFrame) { var ans = f.ans; step = f.step; var t1 = f.vars[0]; var fst = f.vars[1]; var rst = f.vars[2]; var t2 = f.vars[3]; l = f.args[1]; f = f.args[0]; } if(GAS-- <= 0) { return { isCont: true, frames: [{ run: map, isFrame: true, vars: [t1, fst, rst, t2], args: [f, l], step: step }] }; } while(true) { switch(step) { case 0: var dispatch = { empty: 1, link: 2 }; step = dispatch[l.$name]; break; case 1: ans = empty step = 5 break; case 2: fst = l[l.$fields[0]]; rst = l[l.$fields[1]]; step = 3; ans = f(fst); break; case 3: t1 = ans; step = 4 ans = map(f, rst); break; case 4: t2 = ans; step = 5 ans = link(t1, t2); break; case 5: GAS++; return ans; } if(ans && ans.isCont) { ans.frames.push({ run: map, isFrame: true, vars: [t1, fst, rst, t2], args: [f, l], step: step }); return ans; } } } var buildList = function(n) { var l = empty; for(var i = 0; i < n; i++) { l = link(i, l); } return l; } run(100, function() { return map(function(l) { return l + 1; }, buildList(4000)); });
Rendered benchmark preparation results:
Suite status:
<idle, ready to run>
Run tests (2)
Previous results
Fork
Test case name
Result
generators
Manual
Fastest:
N/A
Slowest:
N/A
Latest run results:
No previous run results
This benchmark does not have any results yet. Be the first one
to run it!
Autogenerated LLM Summary
(model
llama3.2:3b
, generated one year ago):
The provided benchmark measures the performance of three different approaches to run JavaScript code: Manual, Generators, and Stack Strategies. **Manual**: This approach involves running the code manually by executing it step-by-step. In this case, the manual test simply runs the `map` function with a list of 4000 elements, incrementing each element by 1. **Generators**: This approach uses generators to run the code asynchronously. A generator is a special type of function that can be paused and resumed at specific points, allowing for efficient iteration over large datasets. In this case, the generator test uses the `map` function with a list of 4000 elements, incrementing each element by 1. **Stack Strategies**: This approach uses a stack-based evaluation strategy to run the code asynchronously. The stack strategy involves pushing and popping values onto a stack to evaluate expressions. In this case, the stack strategy test uses the `map` function with a list of 4000 elements, incrementing each element by 1. The benchmark result shows that the Manual approach is significantly faster than the Generators and Stack Strategies approaches. This may be because the Manual approach avoids the overhead of creating and managing generator iterators, as well as the additional bookkeeping required to implement the stack strategy. Here's a high-level overview of the key differences between these approaches: * **Manual**: Run code step-by-step by hand. * **Generators**: Use generators to run code asynchronously. Generators are special functions that can be paused and resumed at specific points, allowing for efficient iteration over large datasets. * **Stack Strategies**: Use a stack-based evaluation strategy to run code asynchronously. **Key differences** | Approach | Advantages | Disadvantages | | --- | --- | --- | | Manual | Fast, lightweight | Requires manual intervention | | Generators | Efficient iteration over large datasets | Additional bookkeeping required | | Stack Strategies | Asynchronous execution | Overhead of stack management | In summary, the benchmark highlights the importance of choosing an efficient approach for running JavaScript code. The Manual approach offers the fastest execution time, but requires manual intervention and may not be suitable for complex or dynamic codebases. The Generators and Stack Strategies approaches offer more flexibility and scalability, but at a potential cost in terms of performance.
Related benchmarks:
Reduce to array
Stack vs Queue
spread vs push set creation 2
fill vs push multiple
fill vs push multiple small
Comments
Confirm delete:
Do you really want to delete benchmark?