Intcode optimisations.

- Work out parameters inline and pass them, to save overhead of
  calling a function
- Reduce number of cases we check for memory bounds, and don't
  add quite so much each time
- Change CSV reading function to just use ASCII chars not a full
  unicode decode

09/.intcode

+201912152221

common/io.go

 import (
 	"bufio"
 	"os"
-	"unicode"
-	"unicode/utf8"
 )
 
 // ReadFileAsInts reads all lines from the given path and returns them in a slice of ints.
 	// Skip leading spaces.
 	start := 0
 	for width := 0; start < len(data); start += width {
-		var r rune
-		r, width = utf8.DecodeRune(data[start:])
-		if !unicode.IsSpace(r) {
+		if data[start] != ' ' {
 			break
 		}
 	}
 
 	// Scan until comma, marking end of word.
-	for width, i := 0, start; i < len(data); i += width {
-		var r rune
-		r, width = utf8.DecodeRune(data[i:])
-		if r == ',' || unicode.IsSpace(r) {
-			return i + width, data[start:i], nil
+	for i := start; i < len(data); i++ {
+		if data[i] == ',' || data[i] == ' ' || data[i] == '\r' || data[i] == '\n' {
+			return i + 1, data[start:i], nil
 		}
 	}
 	// If we're at EOF, we have a final, non-empty, non-terminated word. Return it.

intcode/ops.go

 package intcode
 
 // opcodeFunc is a function that describes an opcode implemented in the VM.
-type opcodeFunc = func(vm *VirtualMachine)
+type opcodeFunc = func(vm *VirtualMachine, arg1, arg2, arg3 *int)
 
 var opcodes = [100]opcodeFunc{
 	1:  addOpcode,
 	99: haltOpcode,
 }
 
+var opcodeArity = [100]int{
+	1:  3,
+	2:  3,
+	3:  1,
+	4:  1,
+	5:  2,
+	6:  2,
+	7:  3,
+	8:  3,
+	9:  1,
+	99: 0,
+}
+
 // addOpcode takes the values specified by args 1 and 2, adds them together, and stores at the memory address given
 // by arg 3.
-func addOpcode(vm *VirtualMachine) {
-	*vm.arg(2) = *vm.arg(0) + *vm.arg(1)
+func addOpcode(vm *VirtualMachine, arg1, arg2, arg3 *int) {
+	*arg3 = *arg1 + *arg2
 	vm.ip += 4
 }
 
 // mulOpcode takes the values specified by args 1 and 2, multiplies them together, and stores at the memory address
 // given by arg 3.
-func mulOpcode(vm *VirtualMachine) {
-	*vm.arg(2) = *vm.arg(0) * *vm.arg(1)
+func mulOpcode(vm *VirtualMachine, arg1, arg2, arg3 *int) {
+	*arg3 = *arg1 * *arg2
 	vm.ip += 4
 }
 
 // readOpCode reads a value from the input stream and stores it at the memory address given by arg 1.
-func readOpCode(vm *VirtualMachine) {
-	*vm.arg(0) = <-vm.Input
+func readOpCode(vm *VirtualMachine, arg1, _, _ *int) {
+	*arg1 = <-vm.Input
 	vm.ip += 2
 }
 
 // writeOpCode writes the value specified by the first argument to the output stream.
-func writeOpCode(vm *VirtualMachine) {
-	vm.Output <- *vm.arg(0)
+func writeOpCode(vm *VirtualMachine, arg1, _, _ *int) {
+	vm.Output <- *arg1
 	vm.ip += 2
 }
 
 // jumpIfTrueOpCode checks if the first argument is not zero, and if so jumps to the second argument.
-func jumpIfTrueOpCode(vm *VirtualMachine) {
-	if *vm.arg(0) != 0 {
-		vm.ip = *vm.arg(1)
+func jumpIfTrueOpCode(vm *VirtualMachine, arg1, arg2, _ *int) {
+	if *arg1 != 0 {
+		vm.ip = *arg2
 	} else {
 		vm.ip += 3
 	}
 }
 
 // jumpIfFalseOpCode checks if the first argument is zero, and if so jumps to the second argument.
-func jumpIfFalseOpCode(vm *VirtualMachine) {
-	if *vm.arg(0) == 0 {
-		vm.ip = *vm.arg(1)
+func jumpIfFalseOpCode(vm *VirtualMachine, arg1, arg2, _ *int) {
+	if *arg1 == 0 {
+		vm.ip = *arg2
 	} else {
 		vm.ip += 3
 	}
 
 // lessThanOpCode checks if the first argument is less than the second, and stores the result at the address given
 // by the third argument.
-func lessThanOpCode(vm *VirtualMachine) {
-	if *vm.arg(0) < *vm.arg(1) {
-		*vm.arg(2) = 1
+func lessThanOpCode(vm *VirtualMachine, arg1, arg2, arg3 *int) {
+	if *arg1 < *arg2 {
+		*arg3 = 1
 	} else {
-		*vm.arg(2) = 0
+		*arg3 = 0
 	}
 	vm.ip += 4
 }
 
 // equalsOpCode checks if the first argument is equal to the second, and stores the result at the address given
 // by the third argument.
-func equalsOpCode(vm *VirtualMachine) {
-	if *vm.arg(0) == *vm.arg(1) {
-		*vm.arg(2) = 1
+func equalsOpCode(vm *VirtualMachine, arg1, arg2, arg3 *int) {
+	if *arg1 == *arg2 {
+		*arg3 = 1
 	} else {
-		*vm.arg(2) = 0
+		*arg3 = 0
 	}
 	vm.ip += 4
 }
 
 // relativeBaseOffsetOpCode increases the relative base by the given argument.
-func relativeBaseOffsetOpCode(vm *VirtualMachine) {
-	vm.rb += *vm.arg(0)
+func relativeBaseOffsetOpCode(vm *VirtualMachine, arg1, _, _ *int) {
+	vm.rb += *arg1
 	vm.ip += 2
 }
 
 // haltOpcode halts the VM and takes no arguments.
-func haltOpcode(vm *VirtualMachine) {
+func haltOpcode(vm *VirtualMachine, _, _, _ *int) {
 	vm.Halted = true
 }

intcode/vm.go

 package intcode
 
+type parameterMode int
+
+const (
+	position  parameterMode = 0
+	immediate parameterMode = 1
+	relative  parameterMode = 2
+)
+
 // VirtualMachine is an IntCode virtual machine.
 type VirtualMachine struct {
-	ip             int
-	rb             int
-	parameterModes uint8
-	relativeModes  uint8
-	Memory         []int
-	Halted         bool
-	Input          chan int
-	Output         chan int
+	ip     int
+	rb     int
+	Memory []int
+	Halted bool
+	Input  chan int
+	Output chan int
 }
 
 // NewVirtualMachine creates a new IntCode virtual machine, initialised to the given slice of memory.
 	copy(memory, vm.Memory)
 
 	return &VirtualMachine{
-		ip:             vm.ip,
-		rb:             vm.rb,
-		parameterModes: vm.parameterModes,
-		relativeModes:  vm.relativeModes,
-		Memory:         memory,
-		Halted:         vm.Halted,
-		Input:          make(chan int, 1),
-		Output:         make(chan int, 1),
-	}
-}
-
-// arg Returns the value of the given argument for the current instruction.
-func (vm *VirtualMachine) arg(pos int) *int {
-	mask := uint8(1) << uint8(pos)
-	if vm.parameterModes&mask == mask {
-		// Parameter mode - the value of the argument is just treated as an int
-		for vm.ip+1+pos > len(vm.Memory) {
-			vm.Memory = append(vm.Memory, make([]int, 1024)...)
-		}
-
-		return &vm.Memory[vm.ip+1+pos]
-	} else if vm.relativeModes&mask == mask {
-		// Relative mode - the value of the argument is treated as a memory offset from the relative base
-		for vm.ip+1+pos > len(vm.Memory) || vm.rb+vm.Memory[vm.ip+1+pos] > len(vm.Memory) {
-			vm.Memory = append(vm.Memory, make([]int, 1024)...)
-		}
-
-		return &vm.Memory[vm.rb+vm.Memory[vm.ip+1+pos]]
-	} else {
-		// Position mode - the value of the argument is treated as a memory offset from the start of the memory
-		for vm.ip+1+pos > len(vm.Memory) || vm.Memory[vm.ip+1+pos] > len(vm.Memory) {
-			vm.Memory = append(vm.Memory, make([]int, 1024)...)
-		}
-
-		return &vm.Memory[vm.Memory[vm.ip+1+pos]]
+		ip:     vm.ip,
+		rb:     vm.rb,
+		Memory: memory,
+		Halted: vm.Halted,
+		Input:  make(chan int, 1),
+		Output: make(chan int, 1),
 	}
 }
 
 // Run repeatedly executes instructions until the VM halts.
 func (vm *VirtualMachine) Run() {
+	var args [3]*int
 	for !vm.Halted {
 		instruction := vm.Memory[vm.ip]
 		opcode := instruction % 100
 
-		vm.parameterModes = 0
-		vm.relativeModes = 0
-		mask := uint8(1)
-		for i := instruction / 100; i > 0; i /= 10 {
-			mode := i % 10
-			if mode == 1 {
-				vm.parameterModes = vm.parameterModes | mask
-			} else if mode == 2 {
-				vm.relativeModes = vm.relativeModes | mask
+		param := instruction / 100
+		for i := 0; i < opcodeArity[opcode]; i++ {
+
+			switch parameterMode(param % 10) {
+
+			// The argument is the actual value
+			case immediate:
+				args[i] = &vm.Memory[vm.ip+1+i]
+
+			// The argument is a memory reference
+			case position:
+				for vm.Memory[vm.ip+1+i] >= len(vm.Memory) {
+					vm.Memory = append(vm.Memory, make([]int, 128)...)
+				}
+				args[i] = &vm.Memory[vm.Memory[vm.ip+1+i]]
+
+			// The argument is a memory reference offset by the relative base
+			case relative:
+				for vm.rb+vm.Memory[vm.ip+1+i] >= len(vm.Memory) {
+					vm.Memory = append(vm.Memory, make([]int, 128)...)
+				}
+				args[i] = &vm.Memory[vm.rb+vm.Memory[vm.ip+1+i]]
+
 			}
-			mask = mask << 1
+
+			param /= 10
 		}
 
-		opcodes[opcode](vm)
+		opcodes[opcode](vm, args[0], args[1], args[2])
 	}
 	if vm.Output != nil {
 		close(vm.Output)