Skip to main content
SimilarExport ZIP
100%

EventsSpeedTests

✓ Published0🌍 Public
HHypercubed
Last edited Oct 17, 2015
Created on Oct 12, 2015

This example demonstrates how a single property added to one function—but not all functions—can trigger V8’s “failed to optimize dispatch” warning in a hot loop. It shows the impact of monomorphic versus polymorphic call-sites for `Function.prototype.apply` when dispatching to multiple callbacks. The code runs 2 million iterations of a `dispatch` function that invokes two callbacks, comparing an unoptimized case, a bound-function variant, and a fixed version using `.bind(0)` to enforce a monomorphic apply site. The included HTML interface and Node command-line tests let users measure execution time differences across the three approaches.

AI-generated description

"Not optimized: Bad value context for arguments value"

Adding a property to one function, but not all functions, causes Not optimized flag on function containing Function.prototype.apply.

Cause

"V8 only recognizes monomorphic .apply call-sites" - @mraleph

Example

See example.js

Fixes

Test in node

node --trace_opt --trace_deopt example.js | grep "failed to optimize dispatch"

Test in browser

jspm install
http-server  # open http://localhost:8080/

Similar vizzes

Loading thumbnail…

EventsSpeedTests emit objects

The visualization compares JavaScript event emitter libraries by plotting operations-per-second benchmarks from Chrome 50 and Node.js 6.1.0, using a horizontal bar chart. Each bar’s length represents throughput, with a dashed line marking the theoretical maximum. The code uses a custom rendering approach with the Canvas API and `requestAnimationFrame` to draw bars, while data is parsed from the gist’s markdown tables. This highlights MiniSignals as the fastest emitter in both environments, outperforming EventEmitter3 and ReactiveProperty.

HHypercubed
62% match
Loading thumbnail…

Gist c4276ed96ff4bd575933c7ad390a7a92

This example demonstrates a custom event-dispatch loop using the D3 dispatch module. It creates a `dispatch` object with a `foo` event, registers a handler, and then triggers that event 3,000 times via `dispatch.call`. The handler checks whether the passed argument is `undefined` and prints a message if so. The page displays the total number of times the handler was called. The code relies on `d3_dispatch.dispatch` and the `on`/`call` methods to manage custom event flow, with no external data source.

HHypercubed
61% match
Loading thumbnail…

Gist d51a566a307b428d98eaf3aa8d2a59a3

This example benchmarks JavaScript event emitter libraries across multiple test scenarios, including initialization, emitting with context, and emitting single or multiple values to one or more listeners. The code runs benchmark suites using `benchmark.js`, comparing libraries such as `EventEmitter3`, `MiniSignals`, `push-stream`, and `signal-lite`, and reports throughput in operations per second. It highlights the fastest performers per scenario, such as `push-stream` leading in the "emit with context" test. The visualization shows raw performance data from Node.js 6.2.1, rendered as plain-text tables with pass/fail assertions and timing summaries.

HHypercubed
60% match
Loading thumbnail…

Gist e92adbf79e3256a0d3e222f140a0433b

This example visualizes the relative performance of 16 JavaScript event-emitter libraries across two benchmark scenarios, “emit objects” and “emit one parameter,” using the raw output of the benchmark runner. The data, drawn from a gist by Hypercubed, is rendered as a grouped horizontal bar chart where each bar’s length corresponds to operations per second (ops/sec), with libraries sorted by speed and the fastest highlighted. The chart uses a simple SVG-based custom layout (likely with d3-scale for axes and d3-array for sorting) rather than a high-level charting library, directly mapping the numeric values to pixel widths. The visualization does not show error margins or statistical significance, only the raw ops/sec values and the benchmark’s “Fastest is” annotation for each test.

HHypercubed
59% match
Loading thumbnail…

Gist c0ec6bb768fd2672307b0807e4ee46fb

This example benchmarks four JavaScript loop styles—a standard `for` loop, a reversed `for` loop, a `for…of` loop, and `forEach`—on a fixed array of ten numbers. It measures execution time by repeating each loop a thousand times via `performance.now()` timestamps, accumulating the total milliseconds. The code defines each loop as a separate function and calls them through a `test` helper, logging the sum to the console. The comparison uses a simple in-memory data array, with no external libraries, focusing on raw loop performance in a JavaScript environment.

MMAKIO135
59% match
Loading thumbnail…

PowerArray benchmarks

This visualization benchmarks the performance of different `forEach` implementations across arrays and typed arrays, showing that native methods on standard arrays are slower than optimized libraries like lodash, underscore, and fast.js, while PowerArray’s custom method rivals them. The bar chart compares operations per second (ops/sec) for each tested scenario, sourced from a benchmark suite generated by Node.js’s `Benchmark` module. The code uses `Benchmark.Suite` to run trials on plain arrays, `Uint16Array`, and PowerArray instances, with libraries like `fast.js`, `underscore`, `lodash`, and native `Array.prototype.forEach` called directly or via `.call`. Data comes from the gist’s `Results.txt` output, and the visualization likely plots these numeric results to highlight performance gaps.

HHypercubed
59% match
Loading thumbnail…

Making Javascript faster

This example presents a markdown document that compiles performance guidelines for JavaScript, sourced from a gist by GerHobbelt and linked to jsPerf benchmarks. The text explains optimization techniques such as using IIFEs over nested functions, avoiding the `arguments` object, and preferring `that` instead of `bind`. It describes the content without a graphical interface, serving as a static textual reference for developers.

GGerHobbelt
57% match
Loading thumbnail…

PowerArray vs....

This example benchmarks the `forEach` method across multiple JavaScript libraries—native `Array.prototype.forEach`, `fast.js`, `underscore`, and `lodash`—applied to three data types: plain arrays, `Float32Array`, and a custom `PowerArray` class. It shows that native `forEach` on a plain array is the baseline, while `fast.js` and `underscore` achieve similar or better throughput on arrays, with `powerArray.forEach` leading all variants. The code uses `process.hrtime()` for high-resolution timing and computes operations per second from a 10-million-element dataset. Results highlight that typed arrays (`Float32Array`) generally slow down iteration, except with `lodash` and `underscore`, which still lag behind array-based calls.

HHypercubed
57% match