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

Matrix 3x3 lib: impact of object type on functions optimization - different type of function argument (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: 4 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 = -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 = -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 = -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

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

LLMs can make mistakes. Check important info.

Based on the provided benchmark results, I will try to infer some information about the performance of the M3 operations.

From the first result for "M3_1", we can see that:

* The execution rate is approximately 144533 executions per second
* This suggests that the operation involving `M3_1` is relatively fast

The results for "M3_2" show slightly lower execution rates (137809 and 59548) compared to "M3_1", suggesting that this operation might be slower.

The "RawUAString" values are similar across all three test names, indicating that the performance difference between them is likely due to differences in input or implementation details rather than a fundamental issue with the operations themselves.

Without more context about the specific operations being performed by M3_1 and M3_2, it's difficult to provide further insights. However, based on these results alone, we can say that:

* `M3_1` seems to be relatively fast
* `M3_2` is slower than `M3_1`
* The performance differences are likely due to input or implementation details

Latest run results:

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

User agent: Mozilla/5.0 (compatible; MSIE 9.0; ReactOS; Win64; x64) Opera 12.18

Browser/OS: Opera 12 on Other

View result in a separate tab

Test name	Executions per second
M3_0	59548.8 Ops/sec
M3_1	144533.2 Ops/sec
M3_2	137809.4 Ops/sec

Related benchmarks:

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

Comparing performance of: M3_0 vs M3_1 vs M3_2

Created: 4 years ago by: Guest

Jump to the latest result

M3_0

M3_1

M3_2

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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