Benchmark: Setting Canvas Pixel 3

HTML Preparation code:

<canvas id="c" width="800" height="300"></canvas>

Script Preparation code:

$c = document.getElementById('c');
$ctx = $c.getContext('2d');
$ctx.clearRect(0, 0, 800, 300);
$px = $ctx.createImageData(1, 1);
$pxls = [];
for (var i=0; i<10000; ++i) $pxls.push({
   x: Math.random() * 800 << 0,
   y: Math.random() * 300 << 0,
   r: Math.random() * 255 << 0,
   g: Math.random() * 255 << 0,
   b: Math.random() * 255 << 0,
   a: Math.random() * 128 << 0 + 128
});
$i = 0;

Tests:

fillRect/concat
for (var i=500;i--;){ var px = $pxls[$i++ % 10000]; $ctx.fillStyle = 'rgba(' + px.r + ',' + px.g + ',' + px.b + ',' + (px.a / 255) + ')'; $ctx.fillRect(px.x, px.y, 1, 1); }
fillRect/join
for (var i=500;i--;){ var px = $pxls[$i++ % 10000]; $ctx.fillStyle = 'rgba(' + [px.r,px.g,px.b,px.a/255].join() + ')'; $ctx.fillRect(px.x, px.y, 1, 1); }
1×1 Image Data
for (var i=500;i--;){ var px=$pxls[$i++ % 10000], d=$px.data; d[0] = px.r; d[1] = px.g; d[2] = px.b; d[3] = px.a; $ctx.putImageData($px, px.x, px.y); }
fillRect/template
for (var i=500;i--;){ var px = $pxls[$i++ % 10000]; $ctx.fillStyle = `rgba(${px.r},${px.g},${px.b},${px.a / 255})`; $ctx.fillRect(px.x, px.y, 1, 1); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
fillRect/concat
fillRect/join
1×1 Image Data
fillRect/template

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 25 days ago):

LLMs can make mistakes. Check important info.

Let's break down the benchmark and explain what's being tested, compared, and other considerations.

**Benchmark Overview**

The benchmark measures the performance of different approaches for drawing a single pixel on a 2D canvas element in JavaScript. The test case uses a predefined array of pixels (`$pxls`) with random RGB and alpha values.

**Benchmark Definition JSON**

The `Script Preparation Code` section sets up the necessary variables:

1. `$c`: gets a reference to a `<canvas>` element.
2. `$ctx`: gets a 2D drawing context for the canvas element.
3. Clears the canvas by resetting its content to a solid black color (0, 0, 0, 255).
4. Creates an image data object (`$px`) with a single pixel (1x1) and an array of pixels (`$pxls`).

The `Html Preparation Code` section defines the HTML structure for the canvas element.

**Individual Test Cases**

Each test case has a different approach to drawing a single pixel on the canvas:

1. **fillRect/concat**: Uses string concatenation to build the `rgba()` function call.
2. **fillRect/join**: Uses an array join to build the `rgba()` function call.
3. **1×1 Image Data**: Uses the `putImageData()` method to draw the pixel on the canvas.
4. **fillRect/template**: Uses a template string (introduced in ECMAScript 2015) to build the `rgba()` function call.

**Comparison of Approaches**

The benchmark compares the performance of these four approaches:

* **String concatenation** (`fillRect/concat`): The slowest approach, as it involves creating a new string object and performing multiple concatenations.
* **Array join** (`fillRect/join`): Faster than string concatenation, but still slower than other methods.
* **putImageData()** (`1×1 Image Data`): Much faster than the previous two approaches, as it leverages optimized WebGL performance for drawing small images.
* **Template strings** (`fillRect/template`): The fastest approach, as it allows for more efficient string creation and manipulation.

**Pros and Cons**

Here are some pros and cons of each approach:

* **String concatenation**: Pros: simple to implement. Cons: slow due to multiple concatenations.
* **Array join**: Pros: slightly faster than string concatenation. Cons: still slower than optimized methods.
* **putImageData()**: Pros: leverages optimized WebGL performance. Cons: requires more complex setup and understanding of image data.
* **Template strings**: Pros: efficient string creation and manipulation. Cons: requires support for ECMAScript 2015.

**Library and Syntax Considerations**

The benchmark uses the `Canvas` API, which is a standard feature in modern web browsers. The template string syntax (`fillRect/template`) is also supported by most modern JavaScript engines.

If the test case used a special JavaScript feature or syntax, it might have affected the results. However, in this case, the focus is on comparing different drawing approaches, not exploring new features.

**Alternatives**

Other alternatives for drawing small images or pixels on a canvas include:

* Using a library like Pixi.js or Fabric.js, which provide optimized rendering and image manipulation capabilities.
* Utilizing WebGL or WebGPU, which offer even more efficient performance for complex graphics workloads.
* Employing custom low-level optimization techniques, such as using inline assembly or native code.

However, these alternatives might not be necessary for simple use cases like this benchmark.

Latest run results:

Run details: (Test run date: 4 years ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/84.0.4147.89 Safari/537.36

Browser/OS: Chrome 84 on Windows

View result in a separate tab

Test name	Executions per second
fillRect/concat	768.0 Ops/sec
fillRect/join	730.8 Ops/sec
1×1 Image Data	114.8 Ops/sec
fillRect/template	756.8 Ops/sec

Related benchmarks:

Setting Canvas Pixel 3 (version: 0)

Comparing performance of: fillRect/concat vs fillRect/join vs 1×1 Image Data vs fillRect/template

Created: 4 years ago by: Guest

Jump to the latest result

fillRect/concat

fillRect/join

1×1 Image Data

fillRect/template

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 25 days ago):