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); } 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):
Let's break down the provided benchmark definition and test cases. **Benchmark Definition** The benchmark is defined as a set of JavaScript functions that measure the performance of different stack strategies for iterating over data structures. The main idea is to compare three approaches: 1. **Generators**: Using the `yield` keyword to create a generator function, which yields values one at a time. 2. **Manual**: A custom implementation using a loop and conditional statements to iterate over the data structure. 3. **Stack strategies**: Using a stack-based approach to iterate over the data structure. **Options Compared** The benchmark compares the performance of each approach in terms of: * Number of executions per second (ExecutionsPerSecond) * Raw UA string, browser, device platform, operating system, and test name **Test Cases** There are two test cases: 1. **Manual**: A custom implementation using a loop and conditional statements to iterate over the data structure. 2. **Generators**: Using the `yield` keyword to create a generator function, which yields values one at a time. **Benchmark Result** The latest benchmark result shows that the **Manual** approach performs significantly better than the **Generators** approach, with an average of 923 executions per second compared to 45 executions per second. **Stack Strategies** Although not explicitly implemented in the provided benchmark definition, stack strategies are mentioned as a third approach. The idea is to use a stack-based data structure to iterate over the data, which can potentially offer better performance than the generator and manual approaches. **Key Takeaways** * Generators can be an efficient way to iterate over data structures, but may not always outperform other approaches. * Manual implementations using loops and conditional statements can be optimized for specific use cases. * Stack strategies have potential benefits in terms of performance, but require careful implementation and optimization. Overall, the benchmark provides valuable insights into the performance characteristics of different stack strategies for iterating over data structures.
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?