Creates an optimized intcode computer

- Reuses objects / arrays for modes, values, and parsed ops rather than
  recreating them every time.
- Adds base-cases for op function calls, rather than always spreading
  our args.

Author: romellem

2019/19/intcode-computer.js renamed to 2019/19/intcode-computer-optimized.js

@@ -35,6 +35,8 @@ class Computer {
 		this.replenish_input = replenish_input;
 		this.outputs = [];
 
+		this.parseOpTime = 0;
+
 		this.OPS = {
 			[ADD]: {
 				name: ADD,
@@ -60,7 +62,7 @@ class Computer {
 				name: INP,
 				realName: 'INP',
 				params: 1,
-				fn: a => {
+				fn: (a) => {
 					this.memory[a] = this.inputs.shift();
 					if (this.replenish_input !== undefined) {
 						this.inputs.push(this.replenish_input);
@@ -73,14 +75,14 @@ class Computer {
 				name: OUT,
 				realName: 'OUT',
 				params: 1,
-				fn: a => this.output(a),
+				fn: (a) => this.output(a),
 			},
 
 			[ARB]: {
 				name: ARB,
 				realName: 'ARB',
 				params: 1,
-				fn: a => (this.relative_base += a),
+				fn: (a) => (this.relative_base += a),
 			},
 
 			[STP]: {
@@ -139,6 +141,32 @@ class Computer {
 			},
 		};
 
+		const ops_list = Object.values(this.OPS);
+		const max_params = Math.max(...ops_list.map((v) => v.params));
+		const shared_modes = Array(max_params).fill('0');
+
+		/**
+		 * Use shared arrays for `modes` and `value`.
+		 *
+		 * We can share a single array for `modes` since we know
+		 * the number of params for an op, meaning if an op has
+		 * 2 params, we can determine the modes for the 1st and
+		 * 2nd values, and the 3rd value will just be "junk" data
+		 * we'll ignore.
+		 *
+		 * The `values` for the ops need to be unique though, since
+		 * we spread out the values into our function call. Also
+		 * good to note that another optimization is we have hard-coded
+		 * fn calls for the number of params. `fn(...[1, 2])` is
+		 * slower than `fn(1, 2)`, so we code for 0 - 3 params, with
+		 * a default case of a spread. Similar libraries like lodash
+		 * do this.
+		 */
+		for (let op of ops_list) {
+			op.modes = shared_modes;
+			op.values = Array(op.params).fill(0);
+		}
+
 		this.halted = false;
 	}
 
@@ -170,23 +198,25 @@ class Computer {
 
 		let full_op = temp_op.padStart(op.params + 2, '0');
 
-		let modes = [];
-
 		// "Parameter modes are single digits, one per parameter, read **right-to-left** from the opcode"
 		for (let i = op.params - 1; i >= 0; i--) {
-			modes.push(full_op[i]);
+			// [0,1,2,3,4,5]
+			// ^ ops.params = 6
+			// 5 -> 0 # |(5 - 6 + 1)| = | 0| = 0
+			// 4 -> 1 # |(4 - 6 + 1)| = |-1| = 1
+			// 3 -> 2 # |(3 - 6 + 1)| = |-2| = 2
+			// 2 -> 3 # |(2 - 6 + 1)| = |-3| = 3
+			// 1 -> 4 # |(1 - 6 + 1)| = |-4| = 4
+			// 0 -> 5 # |(0 - 6 + 1)| = |-5| = 5
+			op.modes[Math.abs(i - op.params + 1)] = full_op[i];
 		}
 
-		return {
-			...op,
-			modes,
-		};
+		return op;
 	}
 
-	runOp({ modes, fn, jumps, write }) {
+	runOp({ modes, values, params, fn, jumps, write }) {
 		this.pointer++;
-		let values = [];
-		for (let i = 0; i < modes.length; i++) {
+		for (let i = 0; i < params; i++) {
 			let mode = modes[i];
 			let value = this.memory[this.pointer + i];
 
@@ -256,7 +286,7 @@ class Computer {
 				 * - I am running an op that does _not_ write to memory
 				 * - Or if I am not at the last parameter in the op
 				 */
-				const can_switch_to_position = !write || i < modes.length - 1;
+				const can_switch_to_position = !write || i < params - 1;
 
 				if (can_switch_to_position && mode === POSITION_MODE) {
 					value = this.memory[value];
@@ -280,14 +310,40 @@ class Computer {
 				value = 0;
 			}
 
-			values.push(value);
+			values[i] = value;
 		}
 
 		// If result is `true`, we moved the pointer
-		let result = fn(...values);
+		let result;
+
+		/**
+		 * Always spreading args is slow, so we can create a few base cases
+		 * (actually all our base cases) to speed up these function calls.
+		 * We still have a default case if for some reason we have an op
+		 * with more than 3 params (we don't), so this code is future proof,
+		 * but this change offers a ~2x speed improvement.
+		 */
+		switch (params) {
+			case 0:
+				result = fn();
+				break;
+			case 1:
+				result = fn(values[0]);
+				break;
+			case 2:
+				result = fn(values[0], values[1]);
+				break;
+			case 3:
+				result = fn(values[0], values[1], values[2]);
+				break;
+			default:
+				// Spreads are slow, so use direct branches for known number of params
+				result = fn(...values);
+				break;
+		}
 
 		if (!jumps || (jumps && !result)) {
-			this.pointer += modes.length;
+			this.pointer += params;
 		}
 	}
 

2019/19/part-two.js

@@ -2,5 +2,5 @@ const { input } = require('./input');
 const { TractorBeam } = require('./tractor-beam');
 
 let tractor_beam = new TractorBeam(input);
-// console.log(tractor_beam.partTwo());
-console.log(tractor_beam.partTwoOptimized());
+console.log(tractor_beam.partTwo());
+// console.log(tractor_beam.partTwoOptimized());

2019/19/tractor-beam.js

@@ -1,4 +1,4 @@
-const { Computer } = require('./intcode-computer.js');
+const { Computer } = require('./intcode-computer-optimized.js');
 const { InfiniteGrid } = require('./infinite-grid.js');
 
 class TractorBeam {
@@ -192,22 +192,14 @@ class TractorBeam {
 			// First, move down until we hit 0
 			do {
 				bottom_edge.y++;
-				let computer = new Computer({
-					memory: this.memory,
-					inputs: [bottom_edge.x, bottom_edge.y],
-				});
-				[output] = computer.run();
+				output = this.computeAt(bottom_edge.x, bottom_edge.y);
 				this.grid.set(bottom_edge.x, bottom_edge.y, output);
 			} while (output === 1);
 
 			// Then, move inward until we hit a `1`
 			do {
 				bottom_edge.x++;
-				let computer = new Computer({
-					memory: this.memory,
-					inputs: [bottom_edge.x, bottom_edge.y],
-				});
-				[output] = computer.run();
+				output = this.computeAt(bottom_edge.x, bottom_edge.y);
 				this.grid.set(bottom_edge.x, bottom_edge.y, output);
 			} while (output === 0);
 		}
@@ -220,11 +212,7 @@ class TractorBeam {
 				do {
 					// Move right until we hit a `0`
 					top_edge.x++;
-					let computer = new Computer({
-						memory: this.memory,
-						inputs: [top_edge.x, top_edge.y],
-					});
-					[output] = computer.run();
+					output = this.computeAt(top_edge.x, top_edge.y);
 					this.grid.set(top_edge.x, top_edge.y, output);
 				} while (output === 1);
 			} while (allow_for_bottom_jumps && top_edge.y !== bottom_edge.y);
@@ -242,6 +230,7 @@ class TractorBeam {
 		// The computer halts after every output, so we create a new one each time
 		let computer = new Computer({ memory: this.memory, inputs: [x, y] });
 		let [output] = computer.run();
+
 		return output;
 	}
 }