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)];
};

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); } }
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]); } }
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); } }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

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 2 months ago):

LLMs can make mistakes. Check important info.

**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**

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

vec3 Arr

vec3 obj

vec3 arr2

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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