Various intcode optimisations

- Store opcodes in an array rather than a map for faster lookup
  (this means storing them as interface{} as otherwise the types
  form a circular dependency, which is icky but worth the
  performance boost).
- Don't dynamically create an 'Arg' function every step of the vm.
  This was *super* expensive.
- Calculate a bitmask of the argument modes instead of relying
  on on-demand div-modding.
- Only buffer a single value in the I/O buffers to reduce the
  size of allocations.

05/main.go

 
 	vm := intcode.NewVirtualMachine(memory)
 	vm.Input <- 1
-	vm.Run()
+	go vm.Run()
 	fmt.Println(last(vm.Output))
 
 	vm.Reset(input)
 	vm.Input <- 5
-	vm.Run()
+	go vm.Run()
 	fmt.Println(last(vm.Output))
 }

intcode/ops.go

 package intcode
 
-// ArgFunc provides the value of an argument for an opcode
-type ArgFunc = func(pos int) int
-
 // OpcodeFunc is a function that describes an opcode implemented in the VM.
-type OpcodeFunc = func(vm *VirtualMachine, param ArgFunc)
+type OpcodeFunc = func(vm *VirtualMachine)
 
 // 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, arg ArgFunc) {
-	vm.Memory[vm.Memory[vm.ip+3]] = arg(0) + arg(1)
+func AddOpcode(vm *VirtualMachine) {
+	vm.Memory[vm.Memory[vm.ip+3]] = vm.arg(0) + vm.arg(1)
 	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, arg ArgFunc) {
-	vm.Memory[vm.Memory[vm.ip+3]] = arg(0) * arg(1)
+func MulOpcode(vm *VirtualMachine) {
+	vm.Memory[vm.Memory[vm.ip+3]] = vm.arg(0) * vm.arg(1)
 	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, arg ArgFunc) {
+func ReadOpCode(vm *VirtualMachine) {
 	vm.Memory[vm.Memory[vm.ip+1]] = <-vm.Input
 	vm.ip += 2
 }
 
 // WriteOpCode writes the value specified by the first argument to the output stream.
-func WriteOpCode(vm *VirtualMachine, arg ArgFunc) {
-	vm.Output <- arg(0)
+func WriteOpCode(vm *VirtualMachine) {
+	vm.Output <- vm.arg(0)
 	vm.ip += 2
 }
 
 // JumpIfTrueOpCode checks if the first argument is not zero, and if so jumps to the second argument.
-func JumpIfTrueOpCode(vm *VirtualMachine, arg ArgFunc) {
-	if arg(0) != 0 {
-		vm.ip = arg(1)
+func JumpIfTrueOpCode(vm *VirtualMachine) {
+	if vm.arg(0) != 0 {
+		vm.ip = vm.arg(1)
 	} else {
 		vm.ip += 3
 	}
 }
 
 // JumpIfFalseOpCode checks if the first argument is zero, and if so jumps to the second argument.
-func JumpIfFalseOpCode(vm *VirtualMachine, arg ArgFunc) {
-	if arg(0) == 0 {
-		vm.ip = arg(1)
+func JumpIfFalseOpCode(vm *VirtualMachine) {
+	if vm.arg(0) == 0 {
+		vm.ip = vm.arg(1)
 	} 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, arg ArgFunc) {
-	if arg(0) < arg(1) {
+func LessThanOpCode(vm *VirtualMachine) {
+	if vm.arg(0) < vm.arg(1) {
 		vm.Memory[vm.Memory[vm.ip+3]] = 1
 	} else {
 		vm.Memory[vm.Memory[vm.ip+3]] = 0
 
 // 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, arg ArgFunc) {
-	if arg(0) == arg(1) {
+func EqualsOpCode(vm *VirtualMachine) {
+	if vm.arg(0) == vm.arg(1) {
 		vm.Memory[vm.Memory[vm.ip+3]] = 1
 	} else {
 		vm.Memory[vm.Memory[vm.ip+3]] = 0
 }
 
 // HaltOpcode halts the VM and takes no arguments.
-func HaltOpcode(vm *VirtualMachine, arg ArgFunc) {
+func HaltOpcode(vm *VirtualMachine) {
 	vm.Halted = true
 }

intcode/vm.go

 package intcode
 
-import (
-	"fmt"
-	"math"
-)
-
 // VirtualMachine is an IntCode virtual machine.
 type VirtualMachine struct {
 	ip      int
-	opcodes map[int]OpcodeFunc
+	modes   uint8
+	opcodes [100]interface{}
 	Memory  []int
 	Halted  bool
 	Input   chan int
 		ip:     0,
 		Memory: memory,
 		Halted: false,
-		Input:  make(chan int, 100),
-		Output: make(chan int, 100),
-		opcodes: map[int]OpcodeFunc{
+		Input:  make(chan int, 1),
+		Output: make(chan int, 1),
+		opcodes: [100]interface{}{
 			1:  AddOpcode,
 			2:  MulOpcode,
 			3:  ReadOpCode,
 	}
 }
 
+func (vm *VirtualMachine) arg(pos int) int {
+	mask := uint8(1) << uint8(pos)
+	if vm.modes&mask == mask {
+		return vm.Memory[vm.ip+1+pos]
+	} else {
+		return vm.Memory[vm.Memory[vm.ip+1+pos]]
+	}
+}
+
 // Run repeatedly executes instructions until the VM halts.
 func (vm *VirtualMachine) Run() {
 	for !vm.Halted {
 		instruction := vm.Memory[vm.ip]
 		opcode := instruction % 100
 
-		vm.opcodes[opcode](vm, func(pos int) int {
-			mode := (instruction / int(math.Pow10(2+pos))) % 10
-			switch mode {
-			case 0:
-				return vm.Memory[vm.Memory[vm.ip+1+pos]]
-			case 1:
-				return vm.Memory[vm.ip+1+pos]
-			default:
-				panic(fmt.Sprintf("Unknown parameter mode: %d", mode))
+		vm.modes = 0
+		mask := uint8(1)
+		for i := instruction / 100; i > 0; i /= 10 {
+			if i%10 == 1 {
+				vm.modes = vm.modes | mask
 			}
-		})
+			mask = mask << 1
+		}
+
+		vm.opcodes[opcode].(OpcodeFunc)(vm)
 	}
 	close(vm.Input)
 	close(vm.Output)
 	copy(vm.Memory, memory)
 	vm.ip = 0
 	vm.Halted = false
-	vm.Input = make(chan int, 100)
-	vm.Output = make(chan int, 100)
+	vm.Input = make(chan int, 1)
+	vm.Output = make(chan int, 1)
 }