Benchmark: matrix test - MeasureThat.net

Script Preparation code:

function addObj(out, a, b) {
    out[0] = a[0] + b[0];
    out[1] = a[1] + b[1];
    out[2] = a[2] + b[2];
    return out;
};

function addArr(out, oo, a, b, ao,bo) {
    out[0+oo] = a[0+ao] + b[0+bo];
    out[1+oo] = a[1+ao] + b[1+bo];
    out[2+oo] = a[2+ao] + b[2+bo];
};

function addArr2(out, a, b, oo, ao,bo) {
    out[0+(oo || 0)] = a[0+(ao || 0)] + b[0+(bo || 0)];
    out[1+(oo || 0)] = a[1+(ao || 0)] + b[1+(bo || 0)];
    out[2+ (oo || 0)] = a[2+(ao || 0)] + b[2+(bo || 0)];
};

​x
 
function addObj(out, a, b) {    out[0] = a[0] + b[0];    out[1] = a[1] + b[1];    out[2] = a[2] + b[2];    return out;};​function addArr(out, oo, a, b, ao,bo) {    out[0+oo] = a[0+ao] + b[0+bo];    out[1+oo] = a[1+ao] + b[1+bo];    out[2+oo] = a[2+ao] + b[2+bo];};​function addArr2(out, a, b, oo, ao,bo) {    out[0+(oo || 0)] = a[0+(ao || 0)] + b[0+(bo || 0)];    out[1+(oo || 0)] = a[1+(ao || 0)] + b[1+(bo || 0)];    out[2+ (oo || 0)] = a[2+(ao || 0)] + b[2+(bo || 0)];};

Tests:

vec3 Arr

var A = new Float32Array(3000);
var B = new Float32Array(3000);
var O = new Float32Array(3000);
for (var i = 0;i < 10000;++i) {
  for (var j=0;j< 1000;++j) {
    addArr(O,j*3,A,B,j*3,j*3);
  }
}

 
var A = new Float32Array(3000);var B = new Float32Array(3000);var O = new Float32Array(3000);for (var i = 0;i < 10000;++i) {  for (var j=0;j< 1000;++j) {    addArr(O,j*3,A,B,j*3,j*3);  }}

vec3 obj

var A = [];
var B = [];
var O = [];

for (var x=0;x<1000;++x) {
  A.push(new Float32Array(3));
  B.push(new Float32Array(3));
  O.push(new Float32Array(3));
}

for (var i = 0;i < 10000;++i) {
  for (var j=0;j< 1000;++j) {
    addObj(O[j],A[j],B[j]);
  }
}

 
var A = [];var B = [];var O = [];​for (var x=0;x<1000;++x) {  A.push(new Float32Array(3));  B.push(new Float32Array(3));  O.push(new Float32Array(3));}​for (var i = 0;i < 10000;++i) {  for (var j=0;j< 1000;++j) {    addObj(O[j],A[j],B[j]);  }}

vec3 arr2

var A = new Float32Array(3000);
var B = new Float32Array(3000);
var O = new Float32Array(3000);
for (var i = 0;i < 10000;++i) {
  for (var j=0;j< 1000;++j) {
    addArr2(O,A,B,j * 3,j*3,j*3);
  }
}

 
var A = new Float32Array(3000);var B = new Float32Array(3000);var O = new Float32Array(3000);for (var i = 0;i < 10000;++i) {  for (var j=0;j< 1000;++j) {    addArr2(O,A,B,j * 3,j*3,j*3);  }}

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

Test case name	Result
vec3 Arr
vec3 obj
vec3 arr2

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 53 on Windows

View result in a separate tab

Test name	Executions per second
vec3 Arr	0.6 Ops/sec
vec3 obj	0.7 Ops/sec
vec3 arr2	0.4 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated 6 months ago):

Benchmark Explanation

MeasureThat.net provides a platform for creating and running JavaScript microbenchmarks to compare the performance of different approaches to solving a specific problem. In this case, we have three individual test cases that measure the performance of adding vectors (3D coordinates) in various ways.

Test Cases

vec3 Arr: This test case uses arrays as input/output data structures. The benchmark measures the execution time of the addArr function, which adds corresponding elements from two arrays to a third array.
vec3 obj: This test case uses objects as input/output data structures. The benchmark measures the execution time of the addObj function, which adds corresponding properties of two objects to a third object.
vec3 arr2: This test case is similar to vec3 Arr, but it uses a modified version of the addArr2 function with optional default values.

Library: Float32Array

The benchmark uses Float32Array as a data structure for storing and manipulating floating-point numbers. A Float32Array is a typed array that represents an array of 32-bit floating-point numbers.

Special JS Feature/Syntax

There are no specific JavaScript features or syntax used in this benchmark, but it does utilize the concept of closures (i.e., the use of var to declare variables within the scope of a function).

Options Compared

The three test cases compare the performance of adding vectors using different data structures:

Arrays: vec3 Arr and vec3 arr2 use arrays as input/output data structures.
Objects: vec3 obj uses objects as input/output data structures.

Pros and Cons of Different Approaches

Array-based approach (vec3 Arr, vec3 arr2):
- Pros:
  - Fast indexing and iteration using array methods like addArr.
  - Compact memory usage compared to object-based approaches.
- Cons:
  - Limited flexibility in accessing and manipulating data due to the rigid structure of arrays.
Object-based approach (vec3 obj):
- Pros:
  - Flexibility in accessing and manipulating data through object properties and methods.
  - Easier to implement more complex logic or data transformations.
- Cons:
  - Generally slower than array-based approaches due to the overhead of dynamic property access.

Other Alternatives

Some other alternatives for adding vectors in JavaScript might include:

Using a library like mathjs or vec3.js, which provide optimized vector arithmetic functions and data structures.
Implementing a custom, optimized vector arithmetic library from scratch using low-level optimization techniques (e.g., SIMD instructions).
Utilizing Web Workers to parallelize the addition process, potentially improving performance on multi-core devices.

LLMs can make mistakes. Check important info.

**Benchmark Explanation**

**Test Cases**

1. **vec3 Arr**: This test case uses arrays as input/output data structures. The benchmark measures the execution time of the `addArr` function, which adds corresponding elements from two arrays to a third array.
2. **vec3 obj**: This test case uses objects as input/output data structures. The benchmark measures the execution time of the `addObj` function, which adds corresponding properties of two objects to a third object.
3. **vec3 arr2**: This test case is similar to `vec3 Arr`, but it uses a modified version of the `addArr2` function with optional default values.

**Library: `Float32Array`**

The benchmark uses `Float32Array` as a data structure for storing and manipulating floating-point numbers. A `Float32Array` is a typed array that represents an array of 32-bit floating-point numbers.

**Special JS Feature/Syntax**

There are no specific JavaScript features or syntax used in this benchmark, but it does utilize the concept of closures (i.e., the use of `var` to declare variables within the scope of a function).

**Options Compared**

The three test cases compare the performance of adding vectors using different data structures:

* **Arrays**: `vec3 Arr` and `vec3 arr2` use arrays as input/output data structures.
* **Objects**: `vec3 obj` uses objects as input/output data structures.

**Pros and Cons of Different Approaches**

1. **Array-based approach (vec3 Arr, vec3 arr2)**:
	* Pros:
		+ Fast indexing and iteration using array methods like `addArr`.
		+ Compact memory usage compared to object-based approaches.
	* Cons:
		+ Limited flexibility in accessing and manipulating data due to the rigid structure of arrays.
2. **Object-based approach (vec3 obj)**:
	* Pros:
		+ Flexibility in accessing and manipulating data through object properties and methods.
		+ Easier to implement more complex logic or data transformations.
	* Cons:
		+ Generally slower than array-based approaches due to the overhead of dynamic property access.

**Other Alternatives**

Some other alternatives for adding vectors in JavaScript might include:

* Using a library like `mathjs` or `vec3.js`, which provide optimized vector arithmetic functions and data structures.
* Implementing a custom, optimized vector arithmetic library from scratch using low-level optimization techniques (e.g., SIMD instructions).
* Utilizing Web Workers to parallelize the addition process, potentially improving performance on multi-core devices.

Related benchmarks:

matrix test (version: 0)

test patterns for matrix perf

Comparing performance of: vec3 Arr vs vec3 obj vs vec3 arr2

Created: 8 years ago by: Guest

Jump to the latest result