Implemented and benchmarked array-map improvement (preallocating outp…

…ut array)

README.md

@@ -138,9 +138,9 @@ faster.js is 556.3% faster (5.008μs) than native
 faster.js is 228.1% faster (11.379μs) than native
 
   array-map large
-    ✓ native x 169,961 ops/sec ±1.51% (57 runs sampled)
-    ✓ faster.js x 706,781 ops/sec ±0.64% (59 runs sampled)
-faster.js is 315.8% faster (4.469μs) than native
+    ✓ native x 179,800 ops/sec ±1.00% (58 runs sampled)
+    ✓ faster.js x 1,706,593 ops/sec ±0.25% (56 runs sampled)
+faster.js is 849.2% faster (4.976μs) than native
 
   array-reduce large
     ✓ native x 200,425 ops/sec ±1.01% (55 runs sampled)

bench/array-map-preallocation.js

@@ -0,0 +1,38 @@
+const benchmark = require('benchmark');
+const utils = require('./utils');
+
+benchmark.options.onAbort = event => console.error(event.currentTarget.error);
+
+['small', 'medium', 'large'].forEach(arraySize => {
+	const suite = new benchmark.Suite();
+	const title = `array-map-preallocation ${arraySize}`;
+
+	suite.add('without preallocation', () => {
+		const _defined = utils.randomArray(arraySize);
+		const _defined2 = (e, i) => e + i;
+		const results = [];
+		for (let _i = 0; _i <= _defined.length - 1; _i++) {
+		  results.push(_defined2(_defined[_i], _i, _defined));
+		}
+	});
+	suite.add('with preallocation', () => {
+		const _defined = utils.randomArray(arraySize);
+		const _defined2 = (e, i) => e + i;
+		const results = new Array(_defined.length);
+		for (let _i = 0; _i <= _defined.length - 1; _i++) {
+		  results[_i] = _defined2(_defined[_i], _i, _defined);
+		}
+	});
+
+	suite.on('start', () => console.log('  ' + title));
+	suite.on('cycle', event => console.log("    ✓ " + event.target));
+	suite.on('complete', function() {
+		const slowest = this.filter('slowest')[0];
+		const fastest = this.filter('fastest')[0];
+		const microsecDelta = ((1000000 / slowest.hz) - (1000000 / fastest.hz)).toFixed(3);
+		const percentFaster = (100 * (fastest.hz - slowest.hz) / slowest.hz).toFixed(1);
+		console.log(fastest.name + ' is ' + percentFaster + '% faster (' + microsecDelta + 'μs) than ' + slowest.name + '\n');
+	});
+
+	suite.run();
+});

src/optimizations/array-map.js

@@ -31,15 +31,18 @@ export default t => ({
 		const assignee = expression.left;
 
 		// If the array is the assignee, we need a temp var to hold the array.
-		const array = expression.right.callee.object;
+		let array = expression.right.callee.object;
 		if (t.isIdentifier(array) && array.name === assignee.name) {
-			mapPath.get('callee.object').replaceWith(defineId(t, path, array, 'const', 'arr'));
+			array = defineId(t, path, array, 'const', 'arr');
+			mapPath.get('callee.object').replaceWith(array);
+		} else {
+			array = getArray(t, path, mapPath);
 		}
 
-		const initAssignment = t.assignmentExpression('=', assignee, t.arrayExpression());
+		const initAssignment = t.assignmentExpression('=', assignee, arrayAllocExpression(t, array));
 		path.insertBefore(t.expressionStatement(initAssignment));
 
-		path.replaceWith(forLoop(t, path, assignee, mapPath));
+		path.replaceWith(forLoop(t, path, array, assignee, mapPath));
 	},
 
 	VariableDeclaration(path, state) {
@@ -51,25 +54,41 @@ export default t => ({
 			return;
 		}
 
+		const mapPath = path.get('declarations.0.init');
+
 		const assignee = declaration.id;
+		const array = getArray(t, path, mapPath);
 
-		const mapPath = path.get('declarations.0.init');
-		path.insertAfter(forLoop(t, path, assignee, mapPath));
-		mapPath.replaceWith(t.arrayExpression());
+		path.insertAfter(forLoop(t, path, array, assignee, mapPath));
+		mapPath.replaceWith(arrayAllocExpression(t, array));
 	},
 });
 
-function forLoop(t, path, assignee, mapPath) {
-	const array = defineIdIfNeeded(t, mapPath.get('callee.object'), path);
+/**
+ * Returns an expression representing:
+ *     new Array(array.length)
+ */
+function arrayAllocExpression(t, array) {
+	return t.newExpression(t.identifier('Array'), [
+		t.memberExpression(array, t.identifier('length')),
+	]);
+}
+
+function getArray(t, path, mapPath) {
+	return defineIdIfNeeded(t, mapPath.get('callee.object'), path);
+}
+
+function forLoop(t, path, array, assignee, mapPath) {
 	const func = extractDynamicFuncIfNeeded(t, mapPath, path);
 	const i = path.scope.generateUidIdentifier('i');
 
 	const newMapCall = t.callExpression(func, [t.memberExpression(array, i, true), i, array]);
 	const forBody = t.blockStatement([
 		t.expressionStatement(
-			t.callExpression(
-				t.memberExpression(assignee, t.identifier('push')),
-				[newMapCall]
+			t.assignmentExpression(
+				'=',
+				t.memberExpression(assignee, i, true),
+				newMapCall
 			)
 		),
 	]);

test/exec/array-filter/literal.js

@@ -2,4 +2,4 @@ function f(e, i, a) {
 	return e > 1;
 }
 
-const results = [1, 2, -1, 5].map(f);
+const results = [1, 2, -1, 5].filter(f);