Benchmark: shaders strings comparisons

Script Preparation code:

var a = `
struct Matrices {
	model: mat4x4f,
	world: mat4x4f,
	modelView: mat4x4f,
	modelViewProjection: mat4x4f
};

fn getVertex2DToUVCoords(vertex: vec2f) -> vec2f {
  return vec2(
    vertex.x * 0.5 + 0.5,
    0.5 - vertex.y * 0.5
  );
}

fn getVertex3DToUVCoords(vertex: vec3f) -> vec2f {
  return vec2(
    vertex.x * 0.5 + 0.5,
    0.5 - vertex.y * 0.5
  );
}


fn getUVCover(uv: vec2f, textureMatrix: mat4x4f) -> vec2f {
  return (textureMatrix * vec4f(uv, 0.0, 1.0)).xy;
}

@group(1) @binding(0) var<uniform> matrices: Matrices;

struct VSOutput {
  @builtin(position) position: vec4f,
  @location(0) uv: vec2f,
  @location(1) normal: vec3f,
};

@fragment fn main(fsInput: VSOutput) -> @location(0) vec4f {
  // normals
  return vec4(normalize(fsInput.normal) * 0.5 + 0.5, 1.0);
}`

var b = `
struct Matrices {
	model: mat4x4f,
	world: mat4x4f,
	modelView: mat4x4f,
	modelViewProjection: mat4x4f
};

fn getVertex2DToUVCoords(vertex: vec2f) -> vec2f {
  return vec2(
    vertex.x * 0.5 + 0.5,
    0.5 - vertex.y * 0.5
  );
}

fn getVertex3DToUVCoords(vertex: vec3f) -> vec2f {
  return vec2(
    vertex.x * 0.5 + 0.5,
    0.5 - vertex.y * 0.5
  );
}


fn getUVCover(uv: vec2f, textureMatrix: mat4x4f) -> vec2f {
  return (textureMatrix * vec4f(uv, 0.0, 1.0)).xy;
}

@group(1) @binding(0) var<uniform> matrices: Matrices;

struct VSOutput {
  @builtin(position) position: vec4f,
  @location(0) uv: vec2f,
  @location(1) normal: vec3f,
};

@fragment fn main(fsInput: VSOutput) -> @location(0) vec4f {
  // normals
  return vec4(normalize(fsInput.normal) * 0.5 + 0.5, 1.0);
}`

var c = `struct Attributes {
	@builtin(vertex_index) vertexIndex : u32,
	@builtin(instance_index) instanceIndex : u32,
	@location(0) position: vec3f,
	@location(1) uv: vec2f,
	@location(2) normal: vec3f
};

struct Matrices {
	model: mat4x4f,
	world: mat4x4f,
	modelView: mat4x4f,
	modelViewProjection: mat4x4f
};

struct Camera {
	model: mat4x4f,
	view: mat4x4f,
	projection: mat4x4f
};

fn getOutputPosition(position: vec3f) -> vec4f {
  return matrices.modelViewProjection * vec4f(position, 1.0);
}

fn getUVCover(uv: vec2f, textureMatrix: mat4x4f) -> vec2f {
  return (textureMatrix * vec4f(uv, 0.0, 1.0)).xy;
}

@group(0) @binding(0) var<uniform> camera: Camera;

@group(1) @binding(0) var<uniform> matrices: Matrices;

struct VertexOutput {
  @builtin(position) position: vec4f,
  @location(0) uv: vec2f,
  @location(1) normal: vec3f,
};

@vertex fn main(
  attributes: Attributes,
) -> VertexOutput {
  var vsOutput: VertexOutput;

  vsOutput.position = getOutputPosition(attributes.position);
  vsOutput.uv = attributes.uv;
  vsOutput.normal = attributes.normal;
  
  return vsOutput;
}`

Tests:

a, b equality
a === b
a, b locale compare
a.localeCompare(b) === 0
a, c equality
a === c
a, c locale compare
a.localeCompare(c) === 0

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
a, b equality
a, b locale compare
a, c equality
a, c locale compare

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 123 on Windows

View result in a separate tab

Test name	Executions per second
a, b equality	7384511.0 Ops/sec
a, b locale compare	7205676.5 Ops/sec
a, c equality	7300067.0 Ops/sec
a, c locale compare	7021438.0 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):

LLMs can make mistakes. Check important info.

Let's break down what is being tested on the provided JSON.

The benchmark tests the performance of JavaScript string comparisons and locale comparisons using different approaches. The test cases are:

1. **Equality**: "a === b" - This test checks if two strings are equal, comparing their values character by character.
2. **Locale Comparison**: "a.localeCompare(b) === 0" - This test checks if two strings have the same locale and compare their values based on that locale's rules.

The benchmark results show the performance of these tests using different JavaScript engines and browsers:

**Benchmark Definition: "a, b equality"**

* Chrome 123 (Desktop, Windows): 7384511.0 executions per second
* Chrome 123 (Desktop, Windows): 7300067.0 executions per second
* Chrome 123 (Desktop, Windows): 7205676.5 executions per second

**Benchmark Definition: "a, b locale compare"**

* Chrome 123 (Desktop, Windows): 7021438.0 executions per second
* Chrome 123 (Desktop, Windows): 7205676.5 executions per second
* Chrome 123 (Desktop, Windows): 7300067.0 executions per second

**Benchmark Definition: "a, c equality"**

* Chrome 123 (Desktop, Windows): 7384511.0 executions per second
* Chrome 123 (Desktop, Windows): 7205676.5 executions per second
* Chrome 123 (Desktop, Windows): 7300067.0 executions per second

**Benchmark Definition: "a, c locale compare"**

* Chrome 123 (Desktop, Windows): 7021438.0 executions per second
* Chrome 123 (Desktop, Windows): 7205676.5 executions per second
* Chrome 123 (Desktop, Windows): 7300067.0 executions per second

In general, the performance of these tests varies depending on the browser and platform used. The equality test seems to be the fastest, while the locale comparison tests are slightly slower.

Now, let's discuss the differences in approach between these tests:

1. **Equality**: This test compares two strings character by character using the `===` operator. This is a simple but straightforward way to compare strings.
2. **Locale Comparison**: This test uses the `localeCompare()` method to compare two strings based on their locale. This method is more complex and takes into account the cultural rules of the locale, which can affect the comparison result.

In terms of performance, the equality test is likely faster because it only compares the values of the two strings without considering any cultural or linguistic nuances. The locale comparison tests are slower because they must consider the cultural rules of the locale, which can lead to more complex comparisons.

Overall, these tests demonstrate the differences in performance between simple string comparisons and locale-based comparisons in JavaScript.

Related benchmarks:

shaders strings comparisons (version: 0)

Comparing performance of: a, b equality vs a, b locale compare vs a, c equality vs a, c locale compare

Created: 2 years ago by: Guest

Jump to the latest result

a, b equality

a, b locale compare

a, c equality

a, c locale compare

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):