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(300); var B = new Float32Array(300); var O = new Float32Array(300); for (var i = 0;i < 10000;++i) { for (var j=0;j< 100;++j) { addArr(O,j*3,A,B,j*3,j*3); } }
vec3 obj
var A = []; var B = []; var O = []; for (var x=0;x<100;++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< 100;++j) { addObj(O[j],A[j],B[j]); } }
vec3 arr2
var A = new Float32Array(300); var B = new Float32Array(300); var O = new Float32Array(300); for (var i = 0;i < 10000;++i) { for (var j=0;j< 100;++j) { addArr2(O,j*3,A,B,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

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

LLMs can make mistakes. Check important info.

**Overview of the Benchmark**

The provided benchmark measures the performance of three different approaches for matrix multiplication in JavaScript, specifically targeting web browsers.

**Benchmark Definition JSON**

The benchmark definition is an object that contains information about the test case:

* `Name`: The name of the test case ("matrix test")
* `Description`: A brief description of the test case
* `Script Preparation Code`: The JavaScript code required to prepare for the test case. This includes two custom functions, `addObj` and `addArr`, which perform matrix multiplication on 1D arrays (`Float32Array`) or objects.
* `Html Preparation Code`: An empty string, indicating that no HTML preparation is needed.

**Individual Test Cases**

There are three test cases:

1. **vec3 Arr**: This test case uses the `addArr` function to multiply two 2D matrices represented as 1D arrays (`Float32Array`) and stores the result in a third 1D array (`Float32Array`). The matrices have dimensions (100, 100) and are multiplied by performing nested loops.
2. **vec3 obj**: This test case uses the `addObj` function to multiply two 2D objects, where each element is an object with three float32 values representing a row in the matrix. The matrices have dimensions (100, 100) and are multiplied using a similar approach to vec3 Arr.
3. **vec3 arr2**: This test case uses the `addArr2` function, which is similar to `addArr`, but allows for optional padding of rows and columns. The matrices have the same dimensions as in vec3 Arr.

**Library Used**

None of the benchmark definitions explicitly use a library like NumJS or MathJS, although they do utilize native JavaScript arrays (`Float32Array`) and objects. However, some libraries may provide similar functionality to these custom functions.

**Special JS Features/Syntax**

The benchmark uses:

* Function expressions (e.g., `var A = function() { ... }`)
* Array literals (e.g., `var B = new Float32Array(300)`)
* Loop constructs (e.g., `for` loops)

These features are standard in modern JavaScript and do not require special knowledge.

**Performance Comparison**

The benchmark compares the performance of three different approaches:

1. **vec3 Arr**: Uses the `addArr` function to multiply matrices represented as 1D arrays.
2. **vec3 obj**: Uses the `addObj` function to multiply matrices represented as objects with float32 values.
3. **vec3 arr2**: Uses the `addArr2` function, which allows for optional padding of rows and columns.

The performance results are reported in executions per second (ExecutionsPerSecond).

**Pros and Cons**

Each approach has its pros and cons:

* **vec3 Arr**: Fast and lightweight, but may not be suitable for large matrices due to the overhead of 1D array indexing.
	+ Pros: Low memory usage, fast execution
	+ Cons: May be slower for large matrices
* **vec3 obj**: More memory-efficient than vec3 Arr, as it uses objects instead of arrays.
	+ Pros: Good memory efficiency, can handle large matrices
	+ Cons: May have overhead due to object creation and indexing
* **vec3 arr2**: Provides optional padding, making it more flexible for different use cases.
	+ Pros: Flexible padding, good performance
	+ Cons: May have overhead due to conditional logic

**Alternatives**

Some alternative approaches could be:

* Using a dedicated library like NumJS or MathJS, which provides optimized matrix multiplication functions.
* Implementing a more advanced algorithm, such as Strassen's matrix multiplication algorithm.
* Using parallelization techniques to take advantage of multi-core processors.

However, the benchmark is focused on measuring JavaScript performance in web browsers, so these alternative approaches may not be directly applicable.

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:48.0) Gecko/20100101 Firefox/48.0

Browser/OS: Firefox 48 on Windows

View result in a separate tab

Test name	Executions per second
vec3 Arr	132.5 Ops/sec
vec3 obj	110.0 Ops/sec
vec3 arr2	0.3 Ops/sec

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 one month ago):