compiler/io.github.aplcornell.viaduct.selection

Package-level declarations

Types

AbstractProtocolComposer

abstract class AbstractProtocolComposer : ProtocolComposer

A ProtocolComposer with sensible defaults.

And

data class And(val props: List<SelectionConstraint>) : SelectionConstraint

CommunicationEvent

data class CommunicationEvent(val send: OutputPort, val recv: InputPort)

Cost

data class Cost<C : CostMonoid<C>>(val features: PersistentMap<CostFeature, C>) : CostMonoid<Cost<C>> , Map<CostFeature, C> , PrettyPrintable

The cost of executing a piece of code or sending a message. Consists of a map of features over some cost monoid.

CostAdd

data class CostAdd(val lhs: SymbolicCost, val rhs: SymbolicCost) : SymbolicCost

CostChoice

data class CostChoice(val choices: List<Pair<SelectionConstraint, SymbolicCost>>) : SymbolicCost

Cost determined by which guard is true. Exactly one guard must be true.

CostEstimator

interface CostEstimator<C : CostMonoid<C>>

A modular cost model for estimating the cost of executing a program given a protocol assignment.

CostFeature

typealias CostFeature = String

CostLiteral

data class CostLiteral(val cost: Int) : SymbolicCost

CostMax

data class CostMax(val lhs: SymbolicCost, val rhs: SymbolicCost) : SymbolicCost

CostMonoid

interface CostMonoid<C : CostMonoid<C>> : PrettyPrintable

A commutative monoid that represents a notion of cost for a feature.

CostMul

data class CostMul(val lhs: Int, val rhs: SymbolicCost) : SymbolicCost

Multiply cost expression with a scalar. Restrict to scalar multiplication to keep constraint problem linear.

False

object False : SelectionConstraint

FunctionVariable

data class FunctionVariable(val function: FunctionName, val variable: Variable) : PrettyPrintable

GuardVisibilityFlag

data class GuardVisibilityFlag(val variable: String) : SelectionConstraint

HostVariable

data class HostVariable(val variable: String) : SelectionConstraint

Implies

data class Implies(val lhs: SelectionConstraint, val rhs: SelectionConstraint) : SelectionConstraint

IntegerCost

class IntegerCost(val cost: Int) : CostMonoid<IntegerCost>

InvalidProtocolAssignmentException

class InvalidProtocolAssignmentException(node: Node, protocol: Protocol) : RuntimeException

Literal

data class Literal(val literalValue: Boolean) : SelectionConstraint

Not

data class Not(val rhs: SelectionConstraint) : SelectionConstraint

data class Or(val props: List<SelectionConstraint>) : SelectionConstraint

ProtocolAssignment

data class ProtocolAssignment(val assignment: Map<FunctionVariable, Protocol>, val propModel: Map<String, Boolean>, val problem: SelectionProblem)

ProtocolCommunication

data class ProtocolCommunication(val events: Set<CommunicationEvent>) : Set<CommunicationEvent>

ProtocolComposer

abstract class ProtocolComposer

ProtocolFactory

interface ProtocolFactory

Generates a list of Protocols that can implement a given Node, along with constraints that specify when using these protocols is valid.

ProtocolSelection

class ProtocolSelection(solver: SelectionProblemSolver, protocolFactory: ProtocolFactory, protocolComposer: ProtocolComposer, costEstimator: CostEstimator<IntegerCost>)

SelectionConstraint

sealed class SelectionConstraint : PrettyPrintable

Custom selection constraints specified for constraint solving during splitting.

SelectionConstraintGenerator

class SelectionConstraintGenerator(program: ProgramNode, protocolFactory: ProtocolFactory, protocolComposer: ProtocolComposer, costEstimator: CostEstimator<IntegerCost>)

SelectionProblem

data class SelectionProblem(val constraints: Set<SelectionConstraint>, val cost: SymbolicCost, val costMap: Map<Node, SymbolicCost> = mapOf())

A constrained optimization problem defined by a set of selection constraints and a cost expression to minimize.

SelectionProblemSolver

interface SelectionProblemSolver

SimpleCostEstimator

class SimpleCostEstimator(protocolComposer: ProtocolComposer, costRegime: SimpleCostRegime) : CostEstimator<IntegerCost>

Cost estimator for Local, Replication and ABY protocols.

SimpleCostRegime

enum SimpleCostRegime : Enum<SimpleCostRegime>

SymbolicCost

sealed class SymbolicCost : CostMonoid<SymbolicCost>

Symbolic cost that will be minimized by a solver.

True

object True : SelectionConstraint

VariableEquals

data class VariableEquals(val var1: FunctionVariable, val var2: FunctionVariable) : SelectionConstraint

Protocols for v1 and v2 are equal.

VariableIn

data class VariableIn(val variable: FunctionVariable, val protocol: Protocol) : SelectionConstraint

VariableIn(v, P) holds when v is selected to be a protocol in P

Z3SelectionProblemSolver

object Z3SelectionProblemSolver : SelectionProblemSolver

Constraint problem using Z3. Z3 has an optimization module that can return models with minimal cost.

Functions

cached

fun ProtocolComposer.cached(): ProtocolComposer

Caches values returned by ProtocolComposer.communicateOrNull so it is called once per source/destination pair.

filter

fun ProtocolFactory.filter(predicate: (Protocol) -> Boolean): ProtocolFactory

Restricts the given factory to protocols that satisfy predicate.

functionVariables

fun SelectionConstraint.functionVariables(): Set<FunctionVariable>

Some convenience functions.

guardVisibilityVariables

fun SelectionConstraint.guardVisibilityVariables(): Set<GuardVisibilityFlag>

hostVariables

fun SelectionConstraint.hostVariables(): Set<HostVariable>

protocols

fun SelectionConstraint.protocols(): Set<Protocol>

readsFrom

fun ExpressionNode.readsFrom(nameAnalysis: NameAnalysis, protocols: Set<Protocol>): SelectionConstraint

States whether an expression reads only from the protocols in protocols.

fun DeclarationNode.readsFrom(nameAnalysis: NameAnalysis, to: Set<Protocol>, from: Set<Protocol>): SelectionConstraint

fun LetNode.readsFrom(nameAnalysis: NameAnalysis, to: Set<Protocol>, from: Set<Protocol>): SelectionConstraint

States that if the let node is stored at any protocol in to, it reads from only the protocols in from.

sendsTo

fun DeclarationNode.sendsTo(nameAnalysis: NameAnalysis, from: Set<Protocol>, to: Set<Protocol>): SelectionConstraint

fun LetNode.sendsTo(nameAnalysis: NameAnalysis, from: Set<Protocol>, to: Set<Protocol>): SelectionConstraint

States that if the let node is stored at any protocol in from, it sends to only the protocols in to.

unions

fun Iterable<ProtocolFactory>.unions(): ProtocolFactory

Combines given factories into a single factory that returns protocols from all of them.

fun Iterable<Pair<Set<ProtocolName>, ProtocolComposer>>.unions(): ProtocolComposer

Combines multiple protocol composers into one.

validateProtocolAssignment

fun validateProtocolAssignment(program: ProgramNode, protocolFactory: ProtocolFactory, protocolComposer: ProtocolComposer, costEstimator: CostEstimator<IntegerCost>, protocolAssignment: ProtocolAssignment)

This function provides a sanity check to ensure that a given protocol assignment satisfies all constraints required on it by the selector.

variableNames

fun SelectionConstraint.variableNames(): Set<String>

Properties

defaultSelectionProblemSolver

val defaultSelectionProblemSolver: SelectionProblemSolver

selectionProblemSolvers

val selectionProblemSolvers: List<Pair<String, SelectionProblemSolver>>

Returns all available SelectionProblemSolver instances.