Benchmark: Matrix 3x3 lib: impact of object type on functions optimization - different type of function argument - v1

Matrix 3x3 lib: impact of object type on functions optimization - different type of function argument - v1 (version: 0)

Does the compiler determine that type of all created matrix-objects is the same? M3_0: matrix-object created in different places - see M3_0.new* functions. M3_1: matrix-object created by constructor - see M3_1 function. M3_2: matrix-object created in one place - see M3_2.newVal function. Affected functions: - mul_a() - setVal() - setCopy() Note: the time of creating matrix-objects is also included.

Comparing performance of: M3_0 vs M3_1 vs M3_2

Created: 6 years ago by: Guest

Jump to the latest result

HTML Preparation code:

<script>"use strict";  //ECMAscript 5

var M3_0 = {
	newIdentity: function(){
		return {
			x1:1., x2:0., x3:0.,
			y1:0., y2:1., y3:0.,
			z1:0., z2:0., z3:1.};
	},
	setIdentity: function(m){
		m.x1=1., m.x2=0., m.x3=0.;
		m.y1=0., m.y2=1., m.y3=0.;
		m.z1=0., m.z2=0., m.z3=1.;

		return m;
	},
	newVal: function(
			x1,x2,x3,
			y1,y2,y3,
			z1,z2,z3){
		return {
			x1:x1, x2:x2, x3:x3,
			y1:y1, y2:y2, y3:y3,
			z1:z1, z2:z2, z3:z3};
	},
	setVal: function( m,
			x1,x2,x3,
			y1,y2,y3,
			z1,z2,z3){
		m.x1=x1, m.x2=x2, m.x3=x3;
		m.y1=y1, m.y2=y2, m.y3=y3;
		m.z1=z1, m.z2=z2, m.z3=z3;

		return m;
	},
	newClone: function(m){
		return {
			x1:m.x1, x2:m.x2, x3:m.x3,
			y1:m.y1, y2:m.y2, y3:m.y3,
			z1:m.z1, z2:m.z2, z3:m.z3};
	},
	setCopy: function(src, dst){
		dst.x1=src.x1, dst.x2=src.x2, dst.x3=src.x3;
		dst.y1=src.y1, dst.y2=src.y2, dst.y3=src.y3;
		dst.z1=src.z1, dst.z2=src.z2, dst.z3=src.z3;

		return dst;
	},
	mul_a: function(a,b, out){
		// hint for optimizing compiler about aliasing (pointer aliasing)
		// https://en.wikipedia.org/wiki/Aliasing_(computing)?oldid=931708672#Conflicts_with_optimization
		if(b !== out){ // a==b   => a!=out
		               // a==out => a!=b

			var      a1=a.x1,  a2=a.x2,  a3=a.x3;
			out.x1 = a1*b.x1 + a2*b.y1 + a3*b.z1;
			out.x2 = a1*b.x2 + a2*b.y2 + a3*b.z2;
			out.x3 = a1*b.x3 + a2*b.y3 + a3*b.z3;

			         a1=a.y1,  a2=a.y2,  a3=a.y3;
			out.y1 = a1*b.x1 + a2*b.y1 + a3*b.z1;
			out.y2 = a1*b.x2 + a2*b.y2 + a3*b.z2;
			out.y3 = a1*b.x3 + a2*b.y3 + a3*b.z3;

			         a1=a.z1,  a2=a.z2,  a3=a.z3;
			out.z1 = a1*b.x1 + a2*b.y1 + a3*b.z1;
			out.z2 = a1*b.x2 + a2*b.y2 + a3*b.z2;
			out.z3 = a1*b.x3 + a2*b.y3 + a3*b.z3;

			return out;
		} else if(a !== b){ // a!=out
			return M3_0.mul_b(a,b, out);
		} else { // a==out==b
			return M3_0.mul_a(a,M3_0.newClone(a), a); //or M3_0.setCopy(M3_0.mul_a(a,a, {}), a)  - need to bench
		}
	},
	mul_b: function(a,b, out){
		// hint for optimizing compiler about aliasing (pointer aliasing)
		// https://en.wikipedia.org/wiki/Aliasing_(computing)?oldid=931708672#Conflicts_with_optimization
		if(a !== out){ // b==a   => b!=out
		               // b==out => b!=a

			var      bx=b.x1,  by=b.y1,  bz=b.z1;
			out.x1 = bx*a.x1 + by*a.x2 + bz*a.x3;
			out.y1 = bx*a.y1 + by*a.y2 + bz*a.y3;
			out.z1 = bx*a.z1 + by*a.z2 + bz*a.z3;

			         bx=b.x2,  by=b.y2,  bz=b.z2;
			out.x2 = bx*a.x1 + by*a.x2 + bz*a.x3;
			out.y2 = bx*a.y1 + by*a.y2 + bz*a.y3;
			out.z2 = bx*a.z1 + by*a.z2 + bz*a.z3;

			         bx=b.x3,  by=b.y3,  bz=b.z3;
			out.x3 = bx*a.x1 + by*a.x2 + bz*a.x3;
			out.y3 = bx*a.y1 + by*a.y2 + bz*a.y3;
			out.z3 = bx*a.z1 + by*a.z2 + bz*a.z3;

			return out;
		} else if(b !== a){ // b!=out
			return M3_0.mul_a(a,b, out);
		} else { // a==out==b
			return M3_0.mul_a(a,M3_0.newClone(a), a); //or M3_0.setCopy(M3_0.mul_a(a,a, {}), a)  - need to bench
		}
	}
};

var M3_1 = function(
		x1,x2,x3,
		y1,y2,y3,
		z1,z2,z3){
	//if(this instanceof M3_1){
		this.x1=x1, this.x2=x2, this.x3=x3;
		this.y1=y1, this.y2=y2, this.y3=y3;
		this.z1=z1, this.z2=z2, this.z3=z3;
	//} else {
	//	return new M3_1(
	//		x1,x2,x3,
	//		y1,y2,y3,
	//		z1,z2,z3);
	//}
};

M3_1.newIdentity = function(){
	return new M3_1(
		1.,0.,0.,
		0.,1.,0.,
		0.,0.,1.);
};
M3_1.setIdentity = function(m){
	m.x1=1., m.x2=0., m.x3=0.;
	m.y1=0., m.y2=1., m.y3=0.;
	m.z1=0., m.z2=0., m.z3=1.;

	return m;
};
M3_1.setVal = function( m,
		x1,x2,x3,
		y1,y2,y3,
		z1,z2,z3){
	m.x1=x1, m.x2=x2, m.x3=x3;
	m.y1=y1, m.y2=y2, m.y3=y3;
	m.z1=z1, m.z2=z2, m.z3=z3;

	return m;
};
M3_1.newClone = function(m){
	return new M3_1(
		m.x1, m.x2, m.x3,
		m.y1, m.y2, m.y3,
		m.z1, m.z2, m.z3);
},
M3_1.setCopy = function(src, dst){
	dst.x1=src.x1, dst.x2=src.x2, dst.x3=src.x3;
	dst.y1=src.y1, dst.y2=src.y2, dst.y3=src.y3;
	dst.z1=src.z1, dst.z2=src.z2, dst.z3=src.z3;

	return dst;
};
M3_1.mul_a = function(a,b, out){
	// hint for optimizing compiler about aliasing (pointer aliasing)
	// https://en.wikipedia.org/wiki/Aliasing_(computing)?oldid=931708672#Conflicts_with_optimization
	if(b !== out){ // a==b   => a!=out
				   // a==out => a!=b

		var      a1=a.x1,  a2=a.x2,  a3=a.x3;
		out.x1 = a1*b.x1 + a2*b.y1 + a3*b.z1;
		out.x2 = a1*b.x2 + a2*b.y2 + a3*b.z2;
		out.x3 = a1*b.x3 + a2*b.y3 + a3*b.z3;

				 a1=a.y1,  a2=a.y2,  a3=a.y3;
		out.y1 = a1*b.x1 + a2*b.y1 + a3*b.z1;
		out.y2 = a1*b.x2 + a2*b.y2 + a3*b.z2;
		out.y3 = a1*b.x3 + a2*b.y3 + a3*b.z3;

				 a1=a.z1,  a2=a.z2,  a3=a.z3;
		out.z1 = a1*b.x1 + a2*b.y1 + a3*b.z1;
		out.z2 = a1*b.x2 + a2*b.y2 + a3*b.z2;
		out.z3 = a1*b.x3 + a2*b.y3 + a3*b.z3;

		return out;
	} else if(a !== b){ // a!=out
		return M3_1.mul_b(a,b, out);
	} else { // a==out==b
		return M3_1.mul_a(a,M3_1.newClone(a), a); //or M3_1.setCopy(M3_1.mul_a(a,a, {}), a)  - need to bench
	}
};
M3_1.mul_b = function(a,b, out){
	// hint for optimizing compiler about aliasing (pointer aliasing)
	// https://en.wikipedia.org/wiki/Aliasing_(computing)?oldid=931708672#Conflicts_with_optimization
	if(a !== out){ // b==a   => b!=out
				   // b==out => b!=a

		var      bx=b.x1,  by=b.y1,  bz=b.z1;
		out.x1 = bx*a.x1 + by*a.x2 + bz*a.x3;
		out.y1 = bx*a.y1 + by*a.y2 + bz*a.y3;
		out.z1 = bx*a.z1 + by*a.z2 + bz*a.z3;

				 bx=b.x2,  by=b.y2,  bz=b.z2;
		out.x2 = bx*a.x1 + by*a.x2 + bz*a.x3;
		out.y2 = bx*a.y1 + by*a.y2 + bz*a.y3;
		out.z2 = bx*a.z1 + by*a.z2 + bz*a.z3;

				 bx=b.x3,  by=b.y3,  bz=b.z3;
		out.x3 = bx*a.x1 + by*a.x2 + bz*a.x3;
		out.y3 = bx*a.y1 + by*a.y2 + bz*a.y3;
		out.z3 = bx*a.z1 + by*a.z2 + bz*a.z3;

		return out;
	} else if(b !== a){ // b!=out
		return M3_1.mul_a(a,b, out);
	} else { // a==out==b
		return M3_1.mul_a(a,M3_1.newClone(a), a); //or M3_1.setCopy(M3_1.mul_a(a,a, {}), a)  - need to bench
	}
};

var M3_2 = {
	newIdentity: function(){
		return M3_2.newVal(
			1.,0.,0.,
			0.,1.,0.,
			0.,0.,1.);
	},
	setIdentity: function(m){
		m.x1=1., m.x2=0., m.x3=0.;
		m.y1=0., m.y2=1., m.y3=0.;
		m.z1=0., m.z2=0., m.z3=1.;

		return m;
	},
	newVal: function(
			x1,x2,x3,
			y1,y2,y3,
			z1,z2,z3){
		return {
			x1:x1, x2:x2, x3:x3,
			y1:y1, y2:y2, y3:y3,
			z1:z1, z2:z2, z3:z3};
	},
	setVal: function( m,
			x1,x2,x3,
			y1,y2,y3,
			z1,z2,z3){
		m.x1=x1, m.x2=x2, m.x3=x3;
		m.y1=y1, m.y2=y2, m.y3=y3;
		m.z1=z1, m.z2=z2, m.z3=z3;

		return m;
	},
	newClone: function(m){
		return M3_2.newVal(
			m.x1, m.x2, m.x3,
			m.y1, m.y2, m.y3,
			m.z1, m.z2, m.z3);
	},
	setCopy: function(src, dst){
		dst.x1=src.x1, dst.x2=src.x2, dst.x3=src.x3;
		dst.y1=src.y1, dst.y2=src.y2, dst.y3=src.y3;
		dst.z1=src.z1, dst.z2=src.z2, dst.z3=src.z3;

		return dst;
	},
	mul_a: function(a,b, out){
		// hint for optimizing compiler about aliasing (pointer aliasing)
		// https://en.wikipedia.org/wiki/Aliasing_(computing)?oldid=931708672#Conflicts_with_optimization
		if(b !== out){ // a==b   => a!=out
		               // a==out => a!=b

			var      a1=a.x1,  a2=a.x2,  a3=a.x3;
			out.x1 = a1*b.x1 + a2*b.y1 + a3*b.z1;
			out.x2 = a1*b.x2 + a2*b.y2 + a3*b.z2;
			out.x3 = a1*b.x3 + a2*b.y3 + a3*b.z3;

			         a1=a.y1,  a2=a.y2,  a3=a.y3;
			out.y1 = a1*b.x1 + a2*b.y1 + a3*b.z1;
			out.y2 = a1*b.x2 + a2*b.y2 + a3*b.z2;
			out.y3 = a1*b.x3 + a2*b.y3 + a3*b.z3;

			         a1=a.z1,  a2=a.z2,  a3=a.z3;
			out.z1 = a1*b.x1 + a2*b.y1 + a3*b.z1;
			out.z2 = a1*b.x2 + a2*b.y2 + a3*b.z2;
			out.z3 = a1*b.x3 + a2*b.y3 + a3*b.z3;

			return out;
		} else if(a !== b){ // a!=out
			return M3_2.mul_b(a,b, out);
		} else { // a==out==b
			return M3_2.mul_a(a,M3_2.newClone(a), a); //or M3_2.setCopy(M3_2.mul_a(a,a, {}), a)  - need to bench
		}
	},
	mul_b: function(a,b, out){
		// hint for optimizing compiler about aliasing (pointer aliasing)
		// https://en.wikipedia.org/wiki/Aliasing_(computing)?oldid=931708672#Conflicts_with_optimization
		if(a !== out){ // b==a   => b!=out
		               // b==out => b!=a

			var      bx=b.x1,  by=b.y1,  bz=b.z1;
			out.x1 = bx*a.x1 + by*a.x2 + bz*a.x3;
			out.y1 = bx*a.y1 + by*a.y2 + bz*a.y3;
			out.z1 = bx*a.z1 + by*a.z2 + bz*a.z3;

			         bx=b.x2,  by=b.y2,  bz=b.z2;
			out.x2 = bx*a.x1 + by*a.x2 + bz*a.x3;
			out.y2 = bx*a.y1 + by*a.y2 + bz*a.y3;
			out.z2 = bx*a.z1 + by*a.z2 + bz*a.z3;

			         bx=b.x3,  by=b.y3,  bz=b.z3;
			out.x3 = bx*a.x1 + by*a.x2 + bz*a.x3;
			out.y3 = bx*a.y1 + by*a.y2 + bz*a.y3;
			out.z3 = bx*a.z1 + by*a.z2 + bz*a.z3;

			return out;
		} else if(b !== a){ // b!=out
			return M3_2.mul_a(a,b, out);
		} else { // a==out==b
			return M3_2.mul_a(a,M3_2.newClone(a), a); //or M3_2.setCopy(M3_2.mul_a(a,a, {}), a)  - need to bench
		}
	}
};

// var prevent_dead_code_elimination   = 0.0;
window.prevent_dead_code_elimination_0 = 0.0;
window.prevent_dead_code_elimination_1 = 0.0;
window.prevent_dead_code_elimination_2 = 0.0;
</script>

Tests:

M3_0
var a = M3_0.newVal( 7., 9., 3., 5.,-8., 5., -8.,-8.,-5.); var b = M3_0.newIdentity(); var c = M3_0.newClone(a); M3_0.mul_a(a,b, a); M3_0.setVal(b, 0.,-5., 1., -8., 5.,-3., -5.,-8., 6.); M3_0.mul_a(c,b, c); M3_0.mul_a(a,c, b); M3_0.setVal(a, -1.,-6., 0., 0., 5., 5., 0., 5., 2.); M3_0.mul_a(b,a, c); M3_0.setCopy(b, a); M3_0.mul_a(b,c, b); M3_0.mul_a(c,a, c); M3_0.mul_a(a,c, a); M3_0.mul_a(b,a, b); M3_0.mul_a(a,b, c); M3_0.mul_a(c,c, a); M3_0.setCopy(a, c); M3_0.setCopy(a, b); M3_0.mul_a(c,b, a); M3_0.setVal(c, 1.,-3.,-3., 2., 0., 2., -4., 7.,-8.); M3_0.mul_a(b,c, b); M3_0.mul_a(a,b, a); window.prevent_dead_code_elimination_0 += +a.x1-a.x2+a.x3 -a.y1+a.y2-a.y3 +a.z1-a.z2+a.z3;
M3_1
var a = new M3_1( 7., 9., 3., 5.,-8., 5., -8.,-8.,-5.); var b = M3_1.newIdentity(); var c = M3_1.newClone(a); M3_1.mul_a(a,b, a); M3_1.setVal(b, 0.,-5., 1., -8., 5.,-3., -5.,-8., 6.); M3_1.mul_a(c,b, c); M3_1.mul_a(a,c, b); M3_1.setVal(a, -1.,-6., 0., 0., 5., 5., 0., 5., 2.); M3_1.mul_a(b,a, c); M3_1.setCopy(b, a); M3_1.mul_a(b,c, b); M3_1.mul_a(c,a, c); M3_1.mul_a(a,c, a); M3_1.mul_a(b,a, b); M3_1.mul_a(a,b, c); M3_1.mul_a(c,c, a); M3_1.setCopy(a, c); M3_1.setCopy(a, b); M3_1.mul_a(c,b, a); M3_1.setVal(c, 1.,-3.,-3., 2., 0., 2., -4., 7.,-8.); M3_1.mul_a(b,c, b); M3_1.mul_a(a,b, a); window.prevent_dead_code_elimination_1 += +a.x1-a.x2+a.x3 -a.y1+a.y2-a.y3 +a.z1-a.z2+a.z3;
M3_2
var a = M3_2.newVal( 7., 9., 3., 5.,-8., 5., -8.,-8.,-5.); var b = M3_2.newIdentity(); var c = M3_2.newClone(a); M3_2.mul_a(a,b, a); M3_2.setVal(b, 0.,-5., 1., -8., 5.,-3., -5.,-8., 6.); M3_2.mul_a(c,b, c); M3_2.mul_a(a,c, b); M3_2.setVal(a, -1.,-6., 0., 0., 5., 5., 0., 5., 2.); M3_2.mul_a(b,a, c); M3_2.setCopy(b, a); M3_2.mul_a(b,c, b); M3_2.mul_a(c,a, c); M3_2.mul_a(a,c, a); M3_2.mul_a(b,a, b); M3_2.mul_a(a,b, c); M3_2.mul_a(c,c, a); M3_2.setCopy(a, c); M3_2.setCopy(a, b); M3_2.mul_a(c,b, a); M3_2.setVal(c, 1.,-3.,-3., 2., 0., 2., -4., 7.,-8.); M3_2.mul_a(b,c, b); M3_2.mul_a(a,b, a); window.prevent_dead_code_elimination_2 += +a.x1-a.x2+a.x3 -a.y1+a.y2-a.y3 +a.z1-a.z2+a.z3;

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
M3_0
M3_1
M3_2

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

It appears that we have the results of some benchmarking tests for an unknown program, likely a mathematical library or framework. Let's analyze the results and try to understand what they might tell us about the performance of the code.

**Benchmark Results**

The benchmark results are presented in a table format with three columns:

* "RawUAString": The raw string output from the browser.
* "Browser": The browser name and version being used.
* "DevicePlatform" and "OperatingSystem": Information about the device platform and operating system used for the test.

**Benchmarking Test Names**

The benchmarking tests are named `M3_0`, `M3_1`, and `M3_2`. These names suggest that they might be related to some kind of mathematical operation or transformation, possibly involving matrix operations (e.g., multiplication).

**Results Analysis**

Let's look at the results:

* **Test M3_0**: Not shown in the provided snippet.
* **Test M3_1**: 140091 executions per second on a Opera 12 browser. This is an extremely high execution rate, suggesting that the code for this test is very optimized and efficient.
* **Test M3_2**: 58830 executions per second on a Opera 12 browser. This is significantly lower than Test M3_1, indicating that the code for this test might be less optimized or have more overhead.

**Some Observations**

* The results show that the code for Test M3_1 is substantially faster than the code for Test M3_2.
* There are several instances of dead code elimination (a optimization technique) enabled in both tests, which might indicate that the code generation process can eliminate redundant or unused code.

**Inference**

Based on these observations and results, it appears that:

* The code for Test M3_1 is highly optimized and efficient, likely due to its simplicity and focus on a specific mathematical operation.
* The code for Test M3_2 might be less optimized or have more overhead, which could be due to its complexity or the inclusion of additional features.

**Further Investigation**

To further understand the performance differences between these tests, I would recommend:

* Reviewing the code for each test to identify potential areas for optimization.
* Analyzing the benchmark results in more detail to understand the exact performance characteristics and any notable trends or patterns.
* Investigating the use of optimization techniques such as dead code elimination, constant folding, and loop unrolling.

Please let me know if you have any further questions or if there's anything else I can help with!

Related benchmarks: