Optimise day 2 some more.

Specify whether the VM uses IO or not, and if not don't create
channels. These are more expensive than I expected, and
pointlessly creating/destroying them thousands of times is
a significant CPU drain.

02/main.go

 
 	pool := &sync.Pool{
 		New: func() interface{} {
-			return intcode.NewVirtualMachine(make([]int, len(input)))
+			return intcode.NewVirtualMachine(make([]int, len(input)), false)
 		},
 	}
 

05/main.go

 	memory := make([]int, len(input))
 	copy(memory, input)
 
-	vm := intcode.NewVirtualMachine(memory)
+	vm := intcode.NewVirtualMachine(memory, true)
 	vm.Input <- 1
 	go vm.Run()
 	fmt.Println(last(vm.Output))

intcode/vm.go

 
 // NewVirtualMachine creates a new IntCode virtual machine, initialised
 // to the given slice of memory.
-func NewVirtualMachine(memory []int) *VirtualMachine {
-	return &VirtualMachine{
+func NewVirtualMachine(memory []int, hasIO bool) *VirtualMachine {
+	vm := &VirtualMachine{
 		ip:     0,
 		Memory: memory,
 		Halted: false,
-		Input:  make(chan int, 1),
-		Output: make(chan int, 1),
 		opcodes: [100]interface{}{
 			1:  AddOpcode,
 			2:  MulOpcode,
 			99: HaltOpcode,
 		},
 	}
+
+	if hasIO {
+		vm.Input = make(chan int, 1)
+		vm.Output = make(chan int, 1)
+	}
+
+	return vm
 }
 
 func (vm *VirtualMachine) arg(pos int) int {
 
 		vm.opcodes[opcode].(OpcodeFunc)(vm)
 	}
-	close(vm.Input)
-	close(vm.Output)
+	if vm.Input != nil {
+		close(vm.Input)
+		close(vm.Output)
+	}
 }
 
 // Reset resets the memory to the given slice, and all other state back to its original value.
 	copy(vm.Memory, memory)
 	vm.ip = 0
 	vm.Halted = false
-	vm.Input = make(chan int, 1)
-	vm.Output = make(chan int, 1)
+	if vm.Input != nil {
+		vm.Input = make(chan int, 1)
+		vm.Output = make(chan int, 1)
+	}
 }

intcode/vm_test.go

 	}
 
 	for _, table := range tables {
-		vm := NewVirtualMachine(table.given)
+		vm := NewVirtualMachine(table.given, false)
 		vm.Run()
 		if !reflect.DeepEqual(table.expected, vm.Memory) {
 			t.Errorf("Evaluation of %v was incorrect, got: %v, want: %v.", table.given, vm.Memory, table.expected)
 	}
 
 	for _, table := range tables {
-		vm := NewVirtualMachine(table.given)
+		vm := NewVirtualMachine(table.given, true)
 
 		for _, v := range table.input {
 			vm.Input <- v