compiler/edu.cornell.cs.apl.viaduct.selection

Package edu.cornell.cs.apl.viaduct.selection

Types

AbstractProtocolComposer

abstract class AbstractProtocolComposer : ProtocolComposer

A ProtocolComposer with sensible defaults.

And

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

CommunicationEvent

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

Cost

data class Cost<C : CostMonoid<C>>(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(lhs: SymbolicCost, rhs: SymbolicCost) : SymbolicCost

CostChoice

data class CostChoice(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(cost: Int) : SymbolicCost

CostMax

data class CostMax(lhs: SymbolicCost, 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(lhs: Int, 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(function: FunctionName, variable: Variable) : PrettyPrintable

GuardVisibilityFlag

data class GuardVisibilityFlag(variable: String) : SelectionConstraint

HostVariable

data class HostVariable(variable: String) : SelectionConstraint

Implies

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

IntegerCost

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

Literal

data class Literal(literalValue: Boolean) : SelectionConstraint

Not

data class Not(rhs: SelectionConstraint) : SelectionConstraint

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

ProtocolAssignment

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

ProtocolCommunication

data class ProtocolCommunication(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(constraints: Set<SelectionConstraint>, cost: SymbolicCost, costMap: Map<Node, SymbolicCost>)

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(var1: FunctionVariable, var2: FunctionVariable) : SelectionConstraint

Protocols for v1 and v2 are equal.

VariableIn

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

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

Z3Selection

class Z3Selection : 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, prots: Set<Protocol>): SelectionConstraint

States whether an expression reads only from the protocols in prots

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 stores 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>