Implementation of Commitment Protocol backend for Viaduct 2.0 (Circuit IR)

.gitignore

@@ -9,6 +9,7 @@
 cmake-build-*/
 
 # IntelliJ
+.idea/
 out/
 
 # mpeltonen/sbt-idea plugin

compiler/src/main/kotlin/io/github/aplcornell/viaduct/backends/CircuitCodeGenerationBackend.kt

@@ -2,6 +2,7 @@ package io.github.aplcornell.viaduct.backends
 
 import io.github.aplcornell.viaduct.backends.aby.ABYBackend
 import io.github.aplcornell.viaduct.backends.cleartext.CleartextBackend
+import io.github.aplcornell.viaduct.backends.commitment.CommitmentBackend
 
 /** Combines all back ends that support circuit code generation. */
-object CircuitCodeGenerationBackend : Backend by listOf(CleartextBackend, ABYBackend).unions()
+object CircuitCodeGenerationBackend : Backend by listOf(CleartextBackend, ABYBackend, CommitmentBackend).unions()

compiler/src/main/kotlin/io/github/aplcornell/viaduct/backends/cleartext/CleartextCircuitCodeGenerator.kt

@@ -1,22 +1,34 @@
 package io.github.aplcornell.viaduct.backends.cleartext
 
+import com.squareup.kotlinpoet.BYTE_ARRAY
 import com.squareup.kotlinpoet.CodeBlock
 import com.squareup.kotlinpoet.MemberName
+import com.squareup.kotlinpoet.ParameterizedTypeName.Companion.parameterizedBy
+import com.squareup.kotlinpoet.TypeName
+import com.squareup.kotlinpoet.asClassName
+import com.squareup.kotlinpoet.asTypeName
 import io.github.aplcornell.viaduct.circuitcodegeneration.AbstractCodeGenerator
 import io.github.aplcornell.viaduct.circuitcodegeneration.Argument
 import io.github.aplcornell.viaduct.circuitcodegeneration.CodeGeneratorContext
 import io.github.aplcornell.viaduct.circuitcodegeneration.UnsupportedCommunicationException
+import io.github.aplcornell.viaduct.circuitcodegeneration.kotlinType
 import io.github.aplcornell.viaduct.circuitcodegeneration.receiveExpected
 import io.github.aplcornell.viaduct.circuitcodegeneration.receiveReplicated
+import io.github.aplcornell.viaduct.circuitcodegeneration.typeTranslator
+import io.github.aplcornell.viaduct.runtime.commitment.Commitment
+import io.github.aplcornell.viaduct.runtime.commitment.Committed
 import io.github.aplcornell.viaduct.syntax.BinaryOperator
 import io.github.aplcornell.viaduct.syntax.Host
 import io.github.aplcornell.viaduct.syntax.Protocol
 import io.github.aplcornell.viaduct.syntax.UnaryOperator
 import io.github.aplcornell.viaduct.syntax.circuit.OperatorNode
 import io.github.aplcornell.viaduct.syntax.operators.Maximum
 import io.github.aplcornell.viaduct.syntax.operators.Minimum
+import io.github.aplcornell.viaduct.syntax.values.HostSetValue
+import io.github.aplcornell.viaduct.backends.commitment.Commitment as CommitmentProtocol
 
 class CleartextCircuitCodeGenerator(context: CodeGeneratorContext) : AbstractCodeGenerator(context) {
+
     override fun operatorApplication(protocol: Protocol, op: OperatorNode, arguments: List<CodeBlock>): CodeBlock =
         when (op.operator) {
             Minimum ->
@@ -112,6 +124,140 @@
         }
     }
 
+    private fun checkPeerValues(
+        peers: HostSetValue,
+        value: CodeBlock,
+        valueType: TypeName,
+        builder: CodeBlock.Builder,
+    ) {
+        val receivingPeers = peers.filter { it != context.host }
+        if (receivingPeers.isNotEmpty()) {
+            for (host in receivingPeers) builder.addStatement("%L", context.send(value, host))
+            builder.addStatement(
+                "%L",
+                receiveExpected(
+                    value,
+                    context.host,
+                    valueType,
+                    receivingPeers,
+                    context,
+                ),
+            )
+        }
+    }
+
+    private fun createCommitment(
+        source: Protocol,
+        target: Protocol,
+        argument: Argument,
+        builder: CodeBlock.Builder,
+    ): CodeBlock {
+        require(context.host in source.hosts + target.hosts)
+        if (source !is Local) {
+            throw UnsupportedCommunicationException(source, target, argument.sourceLocation)
+        }
+        require(target is CommitmentProtocol)
+        if (target.cleartextHost != source.host) {
+            throw UnsupportedCommunicationException(source, target, argument.sourceLocation)
+        }
+
+        val sendingHost = target.cleartextHost
+        val receivingHosts = target.hashHosts
+        return when (context.host) {
+            sendingHost -> {
+                val tempName1 = context.newTemporary("committed")
+                val tempName2 = context.newTemporary("commitment")
+                builder.addStatement(
+                    "val %N = %T(%L)",
+                    tempName1,
+                    (Committed::class).asTypeName(),
+                    argument.value,
+                )
+                builder.addStatement(
+                    "val %N = %N.%M()",
+                    tempName2,
+                    tempName1,
+                    MemberName(Committed.Companion::class.asClassName(), "commitment"),
+                )
+                receivingHosts.forEach {
+                    builder.addStatement("%L", context.send(CodeBlock.of("%N", tempName2), it))
+                }
+                CodeBlock.of("%N", tempName1)
+            }
+
+            in receivingHosts -> {
+                val argType = kotlinType(argument.type.shape, typeTranslator(argument.type.elementType.value))
+                val tempName3 = context.newTemporary("commitment")
+                builder.addStatement(
+                    "val %N = %L",
+                    tempName3,
+                    context.receive((Commitment::class).asTypeName().parameterizedBy(argType), source.host),
+                )
+                checkPeerValues(HostSetValue(receivingHosts), CodeBlock.of("%L.hash", tempName3), BYTE_ARRAY, builder)
+                CodeBlock.of("%N", tempName3)
+            }
+
+            else -> throw IllegalStateException()
+        }
+    }
+
+    private fun openCommitment(
+        source: Protocol,
+        target: Protocol,
+        argument: Argument,
+        builder: CodeBlock.Builder,
+    ): CodeBlock {
+        require(source is CommitmentProtocol)
+        if (target !is Cleartext) {
+            throw UnsupportedCommunicationException(source, target, argument.sourceLocation)
+        }
+        require(context.host in source.hosts + target.hosts)
+
+        val argType = kotlinType(argument.type.shape, typeTranslator(argument.type.elementType.value))
+        val sendingHost = source.cleartextHost
+        val commitmentReceivingHosts = target.hosts.filter { it in source.hashHosts }
+        val cleartextReceivingHosts = target.hosts - commitmentReceivingHosts
+        val omittedHosts = source.hashHosts - target.hosts
+        val receivingHosts = target.hosts
+        return when (context.host) {
+            sendingHost -> {
+                commitmentReceivingHosts.forEach {
+                    builder.addStatement("%L", context.send(argument.value, it))
+                }
+                cleartextReceivingHosts.forEach {
+                    builder.addStatement("%L", context.send(CodeBlock.of("%L.value", argument.value), it))
+                }
+                CodeBlock.of("%L.value", argument.value)
+            }
+            in commitmentReceivingHosts -> {
+                val tempName1 = context.newTemporary("commitTemp")
+                builder.addStatement(
+                    "val %N = %L.%N(%L)",
+                    tempName1,
+                    argument.value,
+                    "open",
+                    context.receive((Committed::class).asTypeName().parameterizedBy(argType), source.cleartextHost),
+                )
+                checkPeerValues(receivingHosts, CodeBlock.of(tempName1), argType, builder)
+                CodeBlock.of("%N", tempName1)
+            }
+            in cleartextReceivingHosts -> {
+                val tempName1 = context.newTemporary("cleartextTemp")
+                builder.addStatement(
+                    "val %N = %L",
+                    tempName1,
+                    context.receive(argType, sendingHost),
+                )
+                checkPeerValues(receivingHosts, CodeBlock.of(tempName1), argType, builder)
+                CodeBlock.of("%N", tempName1)
+            }
+            in omittedHosts -> {
+                CodeBlock.of("")
+            }
+            else -> throw IllegalStateException()
+        }
+    }
+
     override fun import(
         protocol: Protocol,
         arguments: List<Argument>,
@@ -127,6 +273,13 @@
                         CodeBlock.of("")
                     }
                 }
+                is CommitmentProtocol -> {
+                    if (context.host in protocol.hosts + arg.protocol.hosts) {
+                        openCommitment(arg.protocol, protocol, arg, builder)
+                    } else {
+                        CodeBlock.of("")
+                    }
+                }
 
                 else -> throw UnsupportedCommunicationException(arg.protocol, protocol, arg.sourceLocation)
             }
@@ -149,6 +302,13 @@
                         CodeBlock.of("")
                     }
                 }
+                is CommitmentProtocol -> {
+                    if (context.host in protocol.hosts + arg.protocol.hosts) {
+                        createCommitment(protocol, arg.protocol, arg, builder)
+                    } else {
+                        CodeBlock.of("")
+                    }
+                }
 
                 else -> throw UnsupportedCommunicationException(protocol, arg.protocol, arg.sourceLocation)
             }

compiler/src/main/kotlin/io/github/aplcornell/viaduct/backends/commitment/CommitmentBackend.kt

@@ -26,5 +26,5 @@ object CommitmentBackend : Backend {
 
     override fun codeGenerator(context: CodeGeneratorContext): CodeGenerator = CommitmentDispatchCodeGenerator(context)
 
-    override fun circuitCodeGenerator(context: CircuitCodeGeneratorContext): CircuitCodeGenerator = TODO()
+    override fun circuitCodeGenerator(context: CircuitCodeGeneratorContext): CircuitCodeGenerator = CommitmentCircuitCodeGenerator(context)
 }

compiler/src/main/kotlin/io/github/aplcornell/viaduct/backends/commitment/CommitmentCircuitCodeGenerator.kt

@@ -0,0 +1,50 @@
+package io.github.aplcornell.viaduct.backends.commitment
+
+import com.squareup.kotlinpoet.CodeBlock
+import com.squareup.kotlinpoet.ParameterizedTypeName.Companion.parameterizedBy
+import com.squareup.kotlinpoet.TypeName
+import com.squareup.kotlinpoet.asTypeName
+import io.github.aplcornell.viaduct.circuitcodegeneration.AbstractCodeGenerator
+import io.github.aplcornell.viaduct.circuitcodegeneration.Argument
+import io.github.aplcornell.viaduct.circuitcodegeneration.CodeGeneratorContext
+import io.github.aplcornell.viaduct.circuitcodegeneration.UnsupportedCommunicationException
+import io.github.aplcornell.viaduct.circuitcodegeneration.typeTranslator
+import io.github.aplcornell.viaduct.runtime.commitment.Committed
+import io.github.aplcornell.viaduct.syntax.Protocol
+import io.github.aplcornell.viaduct.syntax.types.ValueType
+import io.github.aplcornell.viaduct.runtime.commitment.Commitment as CommitmentValue
+
+/**
+ * Backend code generator for the commitment protocol for the circuit IR.
+ *
+ * Throws an UnsupportedCommunicationException when used in an input program as a computation protocol.
+ * This is because the commitment protocol is only a storage format and not a computation protocol.
+ */
+class CommitmentCircuitCodeGenerator(context: CodeGeneratorContext) : AbstractCodeGenerator(context) {
+    override fun paramType(protocol: Protocol, sourceType: ValueType): TypeName {
+        require(protocol is Commitment)
+        return when (context.host) {
+            protocol.cleartextHost -> (Committed::class).asTypeName().parameterizedBy(typeTranslator(sourceType))
+            in protocol.hashHosts -> (CommitmentValue::class).asTypeName().parameterizedBy(typeTranslator(sourceType))
+            else -> throw IllegalStateException()
+        }
+    }
+
+    override fun storageType(protocol: Protocol, sourceType: ValueType): TypeName {
+        return super.storageType(protocol, sourceType)
+    }
+
+    override fun import(protocol: Protocol, arguments: List<Argument>): Pair<CodeBlock, List<CodeBlock>> {
+        if (arguments.isEmpty()) {
+            return Pair(CodeBlock.of(""), emptyList())
+        }
+        throw UnsupportedCommunicationException(arguments.first().protocol, protocol, arguments.first().sourceLocation)
+    }
+
+    override fun export(protocol: Protocol, arguments: List<Argument>): Pair<CodeBlock, List<CodeBlock>> {
+        if (arguments.isEmpty()) {
+            return Pair(CodeBlock.of(""), emptyList())
+        }
+        throw UnsupportedCommunicationException(arguments.first().protocol, protocol, arguments.first().sourceLocation)
+    }
+}

compiler/tests/should-pass/circuit/cleartext/Commitment1.circuit

@@ -0,0 +1,20 @@
+host alice
+host bob
+host chuck
+
+circuit fun <> move@Local(host = alice)(a: int[]) -> b: int[] {
+    return a
+}
+
+circuit fun <> move2@Replication(hosts = {bob, chuck})(a: int[]) -> b: int[] {
+    return a
+}
+
+fun <> main() -> {
+    val a@Local(host = alice) = alice.input<int[]>()
+    val c@Commitment(sender = alice, receivers = {bob, chuck}) = move<>(a)
+    val d@Replication(hosts = {bob, chuck}) = move2<>(c)
+    val = bob.output<int[]>(d)
+    val = chuck.output<int[]>(d)
+    return
+}

compiler/tests/should-pass/circuit/cleartext/Commitment2.circuit

@@ -0,0 +1,18 @@
+host alice
+host bob
+
+circuit fun <> move@Local(host = alice)(a: int[]) -> b: int[] {
+    return a
+}
+
+circuit fun <> move2@Local(host = bob)(a: int[]) -> b: int[] {
+    return a
+}
+
+fun <> main() -> {
+    val a@Local(host = alice) = alice.input<int[]>()
+    val c@Commitment(sender = alice, receivers = {bob}) = move<>(a)
+    val d@Local(host = bob) = move2<>(c)
+    val = bob.output<int[]>(d)
+    return
+}

compiler/tests/should-pass/circuit/cleartext/Commitment3.circuit

@@ -0,0 +1,21 @@
+host alice
+host bob
+host chuck
+host david
+
+circuit fun <> move@Local(host = alice)(a: int[]) -> b: int[] {
+    return a
+}
+
+circuit fun <> move2@Replication(hosts = {bob, david})(a: int[]) -> b: int[] {
+    return a
+}
+
+fun <> main() -> {
+    val a@Local(host = alice) = alice.input<int[]>()
+    val c@Commitment(sender = alice, receivers = {bob, chuck}) = move<>(a)
+    val d@Replication(hosts = {bob, david}) = move2<>(c)
+    val = bob.output<int[]>(d)
+    val = david.output<int[]>(d)
+    return
+}

compiler/tests/should-pass/circuit/commitment/CommitmentNoArgs.circuit

@@ -0,0 +1,10 @@
+host alice
+host bob
+host chuck
+
+circuit fun <> move@Commitment(sender = alice, receivers = {bob, chuck})() -> {return}
+
+fun <> main() -> {
+    val = move<>()
+    return
+}

examples/inputs/circuit/cleartext/Commitment1-alice.txt

@@ -0,0 +1 @@
+5

examples/inputs/circuit/cleartext/Commitment2-alice.txt

@@ -0,0 +1 @@
+5

examples/inputs/circuit/cleartext/Commitment3-alice.txt

@@ -0,0 +1 @@
+5

examples/outputs/circuit/cleartext/Commitment1-bob.txt

@@ -0,0 +1 @@
+5

examples/outputs/circuit/cleartext/Commitment1-chuck.txt

@@ -0,0 +1 @@
+5

examples/outputs/circuit/cleartext/Commitment2-bob.txt

@@ -0,0 +1 @@
+5

examples/outputs/circuit/cleartext/Commitment3-bob.txt

@@ -0,0 +1 @@
+5

examples/outputs/circuit/cleartext/Commitment3-chuck.txt

@@ -0,0 +1 @@
+

examples/outputs/circuit/cleartext/Commitment3-david.txt

@@ -0,0 +1 @@
+5