Debian Codegraph @

closure-library/closure/goog/vec/vec_array_perf.html

raw
1 <!DOCTYPE html>
2 <html>
3 <!--
4 Copyright 2011 The Closure Library Authors. All Rights Reserved.
5
6 Use of this source code is governed by the Apache License, Version 2.0.
7 See the COPYING file for details.
8
9 -->
10 <head>
11 <meta http-equiv="X-UA-Compatible" content="IE=edge">
12 <title>Closure Performance Tests - Vector Array math</title>
13 <link rel="stylesheet" type="text/css"
14 href="../testing/performancetable.css"/>
15 <script type="text/javascript" src="../base.js"></script>
16 <script type="text/javascript">
17 goog.require('goog.testing.jsunit');
18 goog.require('goog.testing.PerformanceTable');
19 goog.require('goog.vec.Vec4');
20 goog.require('goog.vec.Mat4');
21 </script>
22 </head>
23 <body>
24 <h1>Closure Performance Tests - Vector Array Math</h1>
25 <p>
26 <strong>User-agent:</strong>
27 <script type="text/javascript">document.write(navigator.userAgent);</script>
28 </p>
29 <p>
30 These tests compare various methods of performing vector operations on
31 arrays of vectors.
32 </p>
33 <div id="perfTable"></div>
34 <hr>
35 <script type="text/javascript">
36
37 var table = new goog.testing.PerformanceTable(
38 goog.dom.getElement('perfTable'));
39
40 function createRandomFloat32Array(length) {
41 var array = new Float32Array(length);
42 for (var i = 0; i < length; i++) {
43 array[i] = Math.random();
44 }
45 return array;
46 }
47
48 function createRandomIndexArray(length) {
49 var array = [];
50 for (var i = 0; i < length; i++) {
51 array[i] = Math.floor(Math.random() * length);
52 array[i] = Math.min(length - 1, array[i]);
53 }
54 return array;
55 }
56
57 function createRandomVec4Array(length) {
58 var a = [];
59 for (var i = 0; i < length; i++) {
60 a[i] = goog.vec.Vec4.createFromValues(
61 Math.random(), Math.random(), Math.random(), Math.random());
62 }
63 return a;
64 }
65
66 function createRandomMat4() {
67 var m = goog.vec.Mat4.createFromValues(
68 Math.random(), Math.random(), Math.random(), Math.random(),
69 Math.random(), Math.random(), Math.random(), Math.random(),
70 Math.random(), Math.random(), Math.random(), Math.random(),
71 Math.random(), Math.random(), Math.random(), Math.random());
72 return m;
73 }
74
75 function createRandomMat4Array(length) {
76 var m = [];
77 for (var i = 0; i < length; i++) {
78 m[i] = createRandomMat4();
79 }
80 return m;
81 }
82
83 /**
84 * Vec4Object is a 4-vector object with x,y,z,w components.
85 * @param {number} x The x component.
86 * @param {number} y The y component.
87 * @param {number} z The z component.
88 * @param {number} w The w component.
89 * @constructor
90 */
91 Vec4Object = function(x, y, z, w) {
92 this.x = x;
93 this.y = y;
94 this.z = z;
95 this.w = w;
96 };
97
98 /**
99 * Add two vectors.
100 * @param {Vec4Object} v0 A vector.
101 * @param {Vec4Object} v1 Another vector.
102 * @param {Vec4Object} r The result.
103 */
104 Vec4Object.add = function(v0, v1, r) {
105 r.x = v0.x + v1.x;
106 r.y = v0.y + v1.y;
107 r.z = v0.z + v1.z;
108 r.w = v0.w + v1.w;
109 };
110
111 function createRandomVec4ObjectArray(length) {
112 var a = [];
113 for (var i = 0; i < length; i++) {
114 a[i] = new Vec4Object(
115 Math.random(), Math.random(), Math.random(), Math.random());
116 }
117 return a;
118 }
119
120 function setVec4FromArray(v, a, o) {
121 v[0] = a[o + 0];
122 v[1] = a[o + 1];
123 v[2] = a[o + 2];
124 v[3] = a[o + 3];
125 }
126
127 function setArrayFromVec4(a, o, v) {
128 a[o + 0] = v[0];
129 a[o + 1] = v[1];
130 a[o + 2] = v[2];
131 a[o + 3] = v[3];
132 }
133
134 /**
135 * This is the same as goog.vec.Vec4.add(). Use this to avoid namespace lookup
136 * overheads.
137 * @param {goog.vec.Vec4.Vec4Like} v0 A vector.
138 * @param {goog.vec.Vec4.Vec4Like} v1 Another vector.
139 * @param {goog.vec.Vec4.Vec4Like} r The result.
140 */
141 function addVec4(v0, v1, r) {
142 r[0] = v0[0] + v1[0];
143 r[1] = v0[1] + v1[1];
144 r[2] = v0[2] + v1[2];
145 r[3] = v0[3] + v1[3];
146 }
147
148 function addVec4ByOffset(v0Buf, v0Off, v1Buf, v1Off, rBuf, rOff) {
149 rBuf[rOff + 0] = v0Buf[v0Off + 0] + v1Buf[v1Off + 0];
150 rBuf[rOff + 1] = v0Buf[v0Off + 1] + v1Buf[v1Off + 1];
151 rBuf[rOff + 2] = v0Buf[v0Off + 2] + v1Buf[v1Off + 2];
152 rBuf[rOff + 3] = v0Buf[v0Off + 3] + v1Buf[v1Off + 3];
153 }
154
155 function addVec4ByOptionalOffset(v0, v1, r, opt_v0Off, opt_v1Off, opt_rOff) {
156 if (opt_v0Off && opt_v1Off && opt_rOff) {
157 r[opt_rOff + 0] = v0[opt_v0Off + 0] + v1[opt_v1Off + 0];
158 r[opt_rOff + 1] = v0[opt_v0Off + 1] + v1[opt_v1Off + 1];
159 r[opt_rOff + 2] = v0[opt_v0Off + 2] + v1[opt_v1Off + 2];
160 r[opt_rOff + 3] = v0[opt_v0Off + 3] + v1[opt_v1Off + 3];
161 } else {
162 r[0] = v0[0] + v1[0];
163 r[1] = v0[1] + v1[1];
164 r[2] = v0[2] + v1[2];
165 r[3] = v0[3] + v1[3];
166 }
167 }
168
169 function mat4MultVec4ByOffset(mBuf, mOff, vBuf, vOff, rBuf, rOff) {
170 var x = vBuf[vOff + 0], y = vBuf[vOff + 1],
171 z = vBuf[vOff + 2], w = vBuf[vOff + 3];
172 rBuf[rOff + 0] = x * mBuf[mOff + 0] + y * mBuf[mOff + 4] +
173 z * mBuf[mOff + 8] + w * mBuf[mOff + 12];
174 rBuf[rOff + 1] = x * mBuf[mOff + 1] + y * mBuf[mOff + 5] +
175 z * mBuf[mOff + 9] + w * mBuf[mOff + 13];
176 rBuf[rOff + 2] = x * mBuf[mOff + 2] + y * mBuf[mOff + 6] +
177 z * mBuf[mOff + 10] + w * mBuf[mOff + 14];
178 rBuf[rOff + 3] = x * mBuf[mOff + 3] + y * mBuf[mOff + 7] +
179 z * mBuf[mOff + 11] + w * mBuf[mOff + 15];
180 }
181
182 var NUM_ITERATIONS = 200000;
183
184 function testAddVec4ByOffset() {
185 var nVecs = NUM_ITERATIONS;
186 var nVals = nVecs * 4;
187 var a0 = createRandomFloat32Array(nVals);
188 var a1 = createRandomFloat32Array(nVals);
189 var a2 = new Float32Array(nVals);
190
191 table.run(
192 function() {
193 for (var i = 0; i < nVecs; i++) {
194 addVec4ByOffset(a0, i * 4, a1, i * 4, a2, i * 4);
195 }
196 },
197 'Add vectors using offsets');
198 }
199
200 function testAddVec4ByOptionalOffset() {
201 var nVecs = NUM_ITERATIONS;
202 var nVals = nVecs * 4;
203 var a0 = createRandomFloat32Array(nVals);
204 var a1 = createRandomFloat32Array(nVals);
205 var a2 = new Float32Array(nVals);
206
207 table.run(
208 function() {
209 for (var i = 0; i < nVecs; i++) {
210 addVec4ByOptionalOffset(a0, a1, a2, i * 4, i * 4, i * 4);
211 }
212 },
213 'Add vectors with optional offsets (requires branch)');
214 }
215
216 /**
217 * Check the overhead of using an array of individual
218 * Vec4s (Float32Arrays of length 4).
219 */
220 function testAddVec4ByVec4s() {
221 var nVecs = NUM_ITERATIONS;
222 var a0 = createRandomVec4Array(nVecs);
223 var a1 = createRandomVec4Array(nVecs);
224 var a2 = createRandomVec4Array(nVecs);
225
226 table.run(
227 function() {
228 for (var i = 0; i < nVecs; i++) {
229 addVec4(a0[i], a1[i], a2[i]);
230 }
231 },
232 'Add vectors using an array of Vec4s (Float32Arrays of length 4)');
233 }
234
235 function testAddVec4ByTmp() {
236 var nVecs = NUM_ITERATIONS;
237 var nVals = nVecs * 4;
238 var a0 = createRandomFloat32Array(nVals);
239 var a1 = createRandomFloat32Array(nVals);
240 var a2 = new Float32Array(nVals);
241
242 table.run(
243 function() {
244 var t0 = new Float32Array(4);
245 var t1 = new Float32Array(4);
246 for (var i = 0; i < nVecs; i++) {
247 setVec4FromArray(t0, a0, i * 4);
248 setVec4FromArray(t1, a1, i * 4);
249 addVec4(t0, t1, t0);
250 setArrayFromVec4(a2, i * 4, t0);
251 }
252 },
253 'Add vectors using tmps');
254 }
255
256 /**
257 * Check the overhead of using an array of Objects with the implicit hash
258 * lookups for the x,y,z,w components.
259 */
260 function testAddVec4ByObjects() {
261 var nVecs = NUM_ITERATIONS;
262 var a0 = createRandomVec4ObjectArray(nVecs);
263 var a1 = createRandomVec4ObjectArray(nVecs);
264 var a2 = createRandomVec4ObjectArray(nVecs);
265
266 table.run(
267 function() {
268 for (var i = 0; i < nVecs; i++) {
269 Vec4Object.add(a0[i], a1[i], a2[i]);
270 }
271 },
272 'Add vectors using an array of Objects ' +
273 '(with implicit hash lookups for the x,y,z,w components)');
274 }
275
276 function testAddVec4BySubarray() {
277 var nVecs = NUM_ITERATIONS;
278 var nVals = nVecs * 4;
279 var a0 = createRandomFloat32Array(nVals);
280 var a1 = createRandomFloat32Array(nVals);
281 var a2 = new Float32Array(nVals);
282
283 table.run(
284 function() {
285 for (var i = 0; i < nVecs; i++) {
286 var t0 = a0.subarray(i * 4 * 4);
287 var t1 = a1.subarray(i * 4 * 4);
288 var t2 = a2.subarray(i * 4 * 4);
289 addVec4(t0, t1, t2);
290 }
291 },
292 'Add vectors using Float32Array.subarray()');
293 }
294
295 function testAddVec4ByView() {
296 var nVecs = NUM_ITERATIONS;
297 var nVals = nVecs * 4;
298 var a0 = createRandomFloat32Array(nVals);
299 var a1 = createRandomFloat32Array(nVals);
300 var a2 = new Float32Array(nVals);
301
302 table.run(
303 function() {
304 for (var i = 0; i < nVecs; i++) {
305 var t0 = new Float32Array(a0.buffer, i * 4 * 4);
306 var t1 = new Float32Array(a1.buffer, i * 4 * 4);
307 var t2 = new Float32Array(a2.buffer, i * 4 * 4);
308 addVec4(t0, t1, t2);
309 }
310 },
311 'Add vectors using Float32 view');
312 }
313
314 function testMat4MultVec4ByOffset() {
315 var nVecs = NUM_ITERATIONS;
316 var nVecVals = nVecs * 4;
317 var nMatVals = nVecs * 16;
318 var m = createRandomFloat32Array(nMatVals);
319 var a0 = createRandomFloat32Array(nVecVals);
320 var a1 = new Float32Array(nVecVals);
321
322 table.run(
323 function() {
324 for (var i = 0; i < nVecs; i++) {
325 mat4MultVec4ByOffset(m, i * 16, a0, i * 4, a1, i * 4);
326 }
327 },
328 'vec4 = mat4 * vec4 using offsets.');
329 }
330
331 /**
332 * Check the overhead of using an array of individual
333 * Vec4s (Float32Arrays of length 4).
334 */
335 function testMat4MultVec4ByVec4s() {
336 var nVecs = NUM_ITERATIONS;
337 var a0 = createRandomVec4Array(nVecs);
338 var a1 = createRandomVec4Array(nVecs);
339 var m = createRandomMat4Array(nVecs);
340
341 table.run(
342 function() {
343 for (var i = 0; i < nVecs; i++) {
344 goog.vec.Mat4.multVec4(m[i], a0[i], a1[i]);
345 }
346 },
347 'vec4 = mat4 * vec4 using arrays of Vec4s and Mat4s');
348 }
349
350 /**
351 * Do 10x as many for the one vector tests.
352 * @type {number}
353 */
354 var NUM_ONE_ITERATIONS = NUM_ITERATIONS * 10;
355
356 function testAddOneVec4ByOffset() {
357 var a0 = createRandomFloat32Array(4);
358 var a1 = createRandomFloat32Array(4);
359 var a2 = new Float32Array(4);
360
361 table.run(
362 function() {
363 for (var i = 0; i < NUM_ONE_ITERATIONS; i++) {
364 addVec4ByOffset(a0, 0, a1, 0, a2, 0);
365 }
366 },
367 'Add one vector using offset of 0');
368 }
369
370 function testAddOneVec4() {
371 var a0 = createRandomFloat32Array(4);
372 var a1 = createRandomFloat32Array(4);
373 var a2 = new Float32Array(4);
374
375 table.run(
376 function() {
377 for (var i = 0; i < NUM_ONE_ITERATIONS; i++) {
378 addVec4(a0, a1, a2);
379 }
380 },
381 'Add one vector');
382 }
383
384 function testAddOneVec4ByOptionalOffset() {
385 var a0 = createRandomFloat32Array(4);
386 var a1 = createRandomFloat32Array(4);
387 var a2 = new Float32Array(4);
388
389 table.run(
390 function() {
391 for (var i = 0; i < NUM_ONE_ITERATIONS; i++) {
392 addVec4ByOptionalOffset(a0, a1, a2);
393 }
394 },
395 'Add one vector with optional offsets (requires branch)');
396 }
397
398 function testAddRandomVec4ByOffset() {
399 var nVecs = NUM_ITERATIONS;
400 var nVals = nVecs * 4;
401 var a0 = createRandomFloat32Array(nVals);
402 var a1 = createRandomFloat32Array(nVals);
403 var a2 = new Float32Array(nVals);
404 var i0 = createRandomIndexArray(nVecs);
405 var i1 = createRandomIndexArray(nVecs);
406 var i2 = createRandomIndexArray(nVecs);
407
408 table.run(
409 function() {
410 for (var i = 0; i < nVecs; i++) {
411 addVec4ByOffset(a0, i0[i] * 4, a1, i1[i] * 4, a2, i2[i] * 4);
412 }
413 },
414 'Add random vectors using offsets');
415 }
416
417 function testAddRandomVec4ByVec4s() {
418 var nVecs = NUM_ITERATIONS;
419 var a0 = createRandomVec4Array(nVecs);
420 var a1 = createRandomVec4Array(nVecs);
421 var a2 = createRandomVec4Array(nVecs);
422 var i0 = createRandomIndexArray(nVecs);
423 var i1 = createRandomIndexArray(nVecs);
424 var i2 = createRandomIndexArray(nVecs);
425
426 table.run(
427 function() {
428 for (var i = 0; i < nVecs; i++) {
429 addVec4(a0[i0[i]], a1[i1[i]], a2[i2[i]]);
430 }
431 },
432 'Add random vectors using an array of Vec4s');
433 }
434
435 // Make sure the tests are run in the order they are defined.
436 var testCase = new goog.testing.TestCase(document.title);
437 testCase.order = goog.testing.TestCase.Order.NATURAL;
438 testCase.autoDiscoverTests();
439 G_testRunner.initialize(testCase);
440
441 </script>
442 </body>
443 </html>