Solution 2017-18, part 2 (Duet)

Author: rhaendel

src/main/kotlin/de/ronny_h/aoc/year2017/day18/Duet.kt

@@ -4,21 +4,67 @@ import de.ronny_h.aoc.AdventOfCode
 import de.ronny_h.aoc.extensions.numbers.isInt
 import de.ronny_h.aoc.extensions.numbers.toIntChecked
 import de.ronny_h.aoc.year2017.day18.Instruction.*
+import kotlinx.coroutines.*
+import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.channels.Channel.Factory.UNLIMITED
+import kotlinx.coroutines.channels.ReceiveChannel
+import kotlinx.coroutines.channels.SendChannel
 
-fun main() = Duet().run(9423, 0)
+fun main() = Duet().run(9423, 7620)
 
 class Duet : AdventOfCode<Long>(2017, 18) {
-    override fun part1(input: List<String>): Long = SoundPlayer(input.parseInstructions()).run()
+    override fun part1(input: List<String>): Long = runBlocking {
+        return@runBlocking Program(input).run()
+    }
+
+    @OptIn(ExperimentalCoroutinesApi::class)
+    override fun part2(input: List<String>): Long = runBlocking {
+        val channel0 = Channel<Long>(UNLIMITED)
+        val channel1 = Channel<Long>(UNLIMITED)
+        val program0 = Program(input, 0, channel0, channel1)
+        val program1 = Program(input, 1, channel1, channel0)
+
+        val job0 = launch { program0.run() }
+        val job1 = launch { program1.run() }
+
+        launch {
+            runDeadlockDetection(program0, program1, channel0, channel1)
+            job0.cancelAndJoin()
+            job1.cancelAndJoin()
+        }
+
+        job0.join()
+        println("program 0 completed")
+        job1.join()
+        println("program 1 completed")
 
-    override fun part2(input: List<String>): Long {
-        return 0
+        return@runBlocking program1.getNumberOfSends()
+    }
+
+    @OptIn(ExperimentalCoroutinesApi::class)
+    private suspend fun runDeadlockDetection(
+        program0: Program,
+        program1: Program,
+        channel0: Channel<Long>,
+        channel1: Channel<Long>,
+    ) {
+        while (true) {
+            delay(100)
+            if (program0.isReceiving && program1.isReceiving && channel0.isEmpty && channel1.isEmpty) {
+                println("deadlock detected!")
+                return
+            }
+        }
     }
 }
 
-fun List<String>.parseInstructions(): List<Instruction> = map {
+fun List<String>.parseInstructions(
+    sendChannel: SendChannel<Long>?,
+    receiveChannel: ReceiveChannel<Long>?
+): List<Instruction> = map {
     val parameters = it.substring(4)
     when (it.substring(0, 3)) {
-        "snd" -> Sound(parameters)
+        "snd" -> sendChannel?.let { Send(parameters.toValue(), sendChannel) } ?: Sound(parameters)
         "set" -> {
             val (register, value) = parameters.split(" ")
             SetValue(register, value.toValue())
@@ -39,13 +85,11 @@ fun List<String>.parseInstructions(): List<Instruction> = map {
             Modulo(register, value.toValue())
         }
 
-        "rcv" -> {
-            Recover(parameters)
-        }
+        "rcv" -> receiveChannel?.let { Receive(parameters, receiveChannel) } ?: Recover(parameters)
 
         "jgz" -> {
-            val (register, value) = parameters.split(" ")
-            JumpIfGreaterZero(register, value.toValue())
+            val (value, offset) = parameters.split(" ")
+            JumpIfGreaterZero(value.toValue(), offset.toValue())
         }
 
         else -> error("unknown instruction: $it")
@@ -70,80 +114,114 @@ sealed interface Value {
     }
 }
 
-sealed interface Instruction {
-    fun executeOn(registers: MutableMap<String, Long>): Long
+private const val PROGRAM_NUMBER_REGISTER = "programNumber"
+private const val LAST_PLAYED_SOUND_REGISTER = "lastPlayedSound"
+private const val NUMBER_OF_SENDS_REGISTER = "numberOfSends"
 
-    companion object {
-        private const val LAST_PLAYED_SOUND_REGISTER = "lastPlayedSound"
-    }
+sealed interface Instruction {
+    suspend fun executeOn(registers: MutableMap<String, Long>): Long
 
     data class Sound(private val register: String) : Instruction {
-        override fun executeOn(registers: MutableMap<String, Long>): Long {
+        override suspend fun executeOn(registers: MutableMap<String, Long>): Long {
             val frequency = registers.getValue(register)
-            println("playing frequency $frequency")
             registers[LAST_PLAYED_SOUND_REGISTER] = frequency
             return frequency
         }
     }
 
+    data class Send(private val value: Value, private val channel: SendChannel<Long>) : Instruction {
+        override suspend fun executeOn(registers: MutableMap<String, Long>): Long {
+            val toSend = value.toNumber(registers)
+            channel.send(toSend)
+            val numberOfSends = registers.getValue(NUMBER_OF_SENDS_REGISTER) + 1
+            registers[NUMBER_OF_SENDS_REGISTER] = numberOfSends
+//            println("${registers[PROGRAM_NUMBER_REGISTER]}: sent $toSend [$numberOfSends]")
+            return toSend
+        }
+    }
+
     data class SetValue(private val register: String, val value: Value) : Instruction {
-        override fun executeOn(registers: MutableMap<String, Long>): Long {
+        override suspend fun executeOn(registers: MutableMap<String, Long>): Long {
             registers[register] = value.toNumber(registers)
             return registers.getValue(register)
         }
     }
 
     data class Add(private val register: String, val value: Value) : Instruction {
-        override fun executeOn(registers: MutableMap<String, Long>): Long {
+        override suspend fun executeOn(registers: MutableMap<String, Long>): Long {
             registers[register] = registers.getValue(register) + value.toNumber(registers)
             return registers.getValue(register)
         }
     }
 
     data class Multiply(private val register: String, val value: Value) : Instruction {
-        override fun executeOn(registers: MutableMap<String, Long>): Long {
+        override suspend fun executeOn(registers: MutableMap<String, Long>): Long {
             registers[register] = registers.getValue(register) * value.toNumber(registers)
             return registers.getValue(register)
         }
     }
 
     data class Modulo(private val register: String, val value: Value) : Instruction {
-        override fun executeOn(registers: MutableMap<String, Long>): Long {
+        override suspend fun executeOn(registers: MutableMap<String, Long>): Long {
             registers[register] = registers.getValue(register) % value.toNumber(registers)
             return registers.getValue(register)
         }
     }
 
     data class Recover(val register: String) : Instruction {
-        override fun executeOn(registers: MutableMap<String, Long>): Long {
+        override suspend fun executeOn(registers: MutableMap<String, Long>): Long {
             if (registers.getValue(register) != 0L) {
-                val frequency = registers.getValue(LAST_PLAYED_SOUND_REGISTER)
-                println("recover last played sound's frequency: $frequency")
-                return frequency
+                return registers.getValue(LAST_PLAYED_SOUND_REGISTER)
             }
             return 0
         }
     }
 
-    data class JumpIfGreaterZero(private val register: String, val value: Value) : Instruction {
-        override fun executeOn(registers: MutableMap<String, Long>): Long {
-            if (registers.getValue(register) > 0) {
-                return value.toNumber(registers)
+    data class Receive(private val register: String, private val channel: ReceiveChannel<Long>) : Instruction {
+        override suspend fun executeOn(registers: MutableMap<String, Long>): Long {
+            val value = channel.receive()
+//            println("${registers[PROGRAM_NUMBER_REGISTER]}: received $value")
+            registers[register] = value
+            return value
+        }
+    }
+
+    data class JumpIfGreaterZero(private val value: Value, private val offset: Value) : Instruction {
+        override suspend fun executeOn(registers: MutableMap<String, Long>): Long {
+            if (value.toNumber(registers) > 0) {
+                return offset.toNumber(registers)
             }
             return 1
         }
     }
 }
 
-class SoundPlayer(private val instructions: List<Instruction>) {
-    private val registers = mutableMapOf<String, Long>().withDefault { 0 }
+class Program(
+    input: List<String>,
+    programNumber: Long = 0,
+    sendChannel: Channel<Long>? = null,
+    receiveChannel: Channel<Long>? = null,
+) {
+    var isReceiving = false
+
+    private val instructions = input.parseInstructions(sendChannel, receiveChannel)
+    private val registers = mutableMapOf(
+        "p" to programNumber,
+        PROGRAM_NUMBER_REGISTER to programNumber,
+    ).withDefault { 0 }
     private var instructionPointer = 0L
 
-    fun run(): Long {
+    suspend fun run(): Long {
+        println("program ${registers[PROGRAM_NUMBER_REGISTER]} started")
         while (instructionPointer in instructions.indices) {
             val instruction = instructions[instructionPointer.toIntChecked()]
+            if (instruction is Receive) {
+                isReceiving = true
+            }
             val result = instruction.executeOn(registers)
+            isReceiving = false
             if (instruction is Recover && registers.getValue(instruction.register) != 0L) {
+                println("program ${registers[PROGRAM_NUMBER_REGISTER]}: instruction \"Recover\" with register not zero -> terminating")
                 return result
             }
             instructionPointer += if (instruction is JumpIfGreaterZero) {
@@ -152,6 +230,9 @@ class SoundPlayer(private val instructions: List<Instruction>) {
                 1L
             }
         }
+        println("program ${registers[PROGRAM_NUMBER_REGISTER]}: instruction pointer ran out of bounds: $instructionPointer -> terminating")
         return -1L
     }
+
+    fun getNumberOfSends(): Long = registers.getValue(NUMBER_OF_SENDS_REGISTER)
 }

src/test/kotlin/de/ronny_h/aoc/year2017/day18/DuetTest.kt

@@ -6,10 +6,12 @@ import de.ronny_h.aoc.year2017.day18.Value.Number
 import de.ronny_h.aoc.year2017.day18.Value.Register
 import io.kotest.core.spec.style.StringSpec
 import io.kotest.matchers.shouldBe
+import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.channels.Channel.Factory.UNLIMITED
 
 class DuetTest : StringSpec({
 
-    val input = """
+    val input1 = """
         set a 1
         add a 2
         mul a a
@@ -22,27 +24,51 @@ class DuetTest : StringSpec({
         jgz a -2
     """.asList()
 
-    "instructions can be parsed" {
-        input.parseInstructions() shouldBe listOf(
+    "instructions with sound can be parsed" {
+        input1.parseInstructions(null, null) shouldBe listOf(
             SetValue("a", Number(1)),
             Add("a", Number(2)),
             Multiply("a", Register("a")),
             Modulo("a", Number(5)),
             Sound("a"),
             SetValue("a", Number(0)),
             Recover("a"),
-            JumpIfGreaterZero("a", Number(-1)),
+            JumpIfGreaterZero(Register("a"), Number(-1)),
             SetValue("a", Number(1)),
-            JumpIfGreaterZero("a", Number(-2)),
+            JumpIfGreaterZero(Register("a"), Number(-2)),
         )
     }
 
     "part 1: the value of the recovered frequency the first time a rcv instruction is executed with a non-zero value" {
-        Duet().part1(input) shouldBe 4
+        Duet().part1(input1) shouldBe 4
     }
 
-    "part 2" {
-        val input = listOf("")
-        Duet().part2(input) shouldBe 0
+    val input2 = """
+        snd 1
+        snd 2
+        snd p
+        rcv a
+        rcv b
+        rcv c
+        rcv d
+    """.asList()
+
+    "instructions with send and receive channels can be parsed" {
+        val channel0 = Channel<Long>(UNLIMITED)
+        val channel1 = Channel<Long>(UNLIMITED)
+
+        input2.parseInstructions(channel0, channel1) shouldBe listOf(
+            Send(Number(1), channel0),
+            Send(Number(2), channel0),
+            Send(Register("p"), channel0),
+            Receive("a", channel1),
+            Receive("b", channel1),
+            Receive("c", channel1),
+            Receive("d", channel1),
+        )
+    }
+
+    "part 2: the number of times program 1 sent a value before a deadlock occurs" {
+        Duet().part2(input2) shouldBe 3
     }
 })