Post on 23-Feb-2016
description
Synthesis with the Sketch System
DAY 1
Armando Solar-Lezama
The ChallengeComputer should help make programming easier
Problem Programming requires insight and experience
Computers are not that smart
Interaction between programmers and tools is key
The sketching approach
Let the programmer control the implementation strategy
Focus the synthesizer on the low-level details
Key design principle: Exploit familiar programming concepts
Example•You want to partition N elements over P procs
How many elements should a processor get?
•Obvious answer is N/P
•Obvious answer is wrong!
N = 18P = 5
void partition(int p, int P, int N, ref int ibeg, ref int iend){ if(p< {$ p, P, N, N/P, N%P : *, + $} ){ iend = {$ p, P, N, N/P, N%P : *, + $}; ibeg = {$ p, P, N, N/P, N%P : *, + $}; }else{ iend = {$ p, P, N, N/P, N%P : *, + $}; ibeg = {$ p, P, N, N/P, N%P : *, + $}; }}
Synthesizing a partition function•What do we know?
The interface to the function we want Not all processors will get the same # of elements The kind of expressions we expect
p
PNN/P
N%P* +
harness void testPartition(int p, int N, int P){ if(p>=P || P < 1){ return; } int ibeg, iend; partition(p, P, N, ibeg, iend); assert iend - ibeg < (N/P) + 2; if(p+1 < P){ int ibeg2, iend2; partition(p+1, P, N, ibeg2, iend2); assert iend == ibeg2; } if(p==0){ assert ibeg == 0; } if(p==P-1){ assert iend == N; } }
Synthesizing a partition function•How does the system know what a partition is?
Partitions should be balanced
Adjacent partitions should match
First and last partition should go all the way to the
ends
DEMO
Solution
void partition(int p, int P, int N, ref int ibeg, ref int iend){ if(p < (N % P)){ iend = ((N / P) + 1) * (1 + p); ibeg = p + ((N / P) * p); }else{ iend = ((N / P) * p) + ((N / P) + (N % P)); ibeg = (N % P) + ((N / P) * p); }}
THE SKETCH LANGUAGE
Sketch language basics •Sketches are programs with holes
write what you know use holes for the rest
Specifications•Idea: Use unit tests as specification
Programmers know how to write those
•Two mechanisms assertions
function equivalenceblockedMatMul(Mat a, Mat b) implements matMul
assert x > y;
Holes•Holes are placeholders for the synthesizer
synthesizer replaces hole with concrete code fragment fragment must come from a set defined by the user
Defining sets of code fragments is the key to Sketching effectively
Language Design StrategyExtend base language with one construct
Constant hole: ??
Synthesizer replaces ?? with a constantHigh-level constructs defined in terms of ??
int bar (int x){ int t = x * ??; assert t == x + x; return t;}
int bar (int x){ int t = x * 2; assert t == x + x; return t;}
Integer Holes Sets of Expressions
•Expressions with ?? == sets of expressions
linear expressions x*?? + y*?? polynomials x*x*?? + x*?? + ??
sets of variables ?? ? x : y
Integer Holes Sets of Expressions•Example: Least Significant Zero Bit
0010 0101 0000 0010
•Trick: Adding 1 to a string of ones turns the next zero to a 1 i.e. 000111 + 1 = 001000
int W = 32;bit[W] isolate0 (bit[W] x) { // W: word size
bit[W] ret = 0;for (int i = 0; i < W; i++)
if (!x[i]) { ret[i] = 1; return ret; } }
!(x + ??) & (x + ??) !(x + 1) & (x + 0)
!(x + 0) & (x + 1)
!(x + 1) & (x + 0xFFFF)
!(x + 0xFFFF) & (x + 1)
Integer Holes Sets of Expressions•Example: Least Significant Zero Bit
0010 0101 0000 0010int W = 32;bit[W] isolate0 (bit[W] x) { // W: word size
bit[W] ret = 0;for (int i = 0; i < W; i++)
if (!x[i]) { ret[i] = 1; return ret; } }
bit[W] isolateSk (bit[W] x) implements isolate0 {
return !(x + ??) & (x + ??) ;}
Integer Holes Sets of Expressions
•Expressions with ?? == sets of expressions linear expressions x*?? + y*?? polynomials x*x*?? + x*?? + ?? sets of variables ?? ? x : y
•Semantically powerful but syntactically clunky Regular Expressions are a more convenient
Regular Expression Generators•{| RegExp |}
•RegExp supports choice ‘|’ and optional ‘?’ can be used arbitrarily within an expression- to select operands {| (x | y | z) + 1 |}- to select operators {| x (+ | -) y |}- to select fields {| n(.prev | .next)? |}- to select arguments {| foo( x | y, z) |}
•Set must respect the type system all expressions in the set must type-check all must be of the same type
Sets of statements•Statements with holes = sets of statements
•Higher level constructs for Statements too repeatbit[W] tmp=0;
repeat(3){ {| x | tmp |} = {| (!)?((x | tmp) (& | +) (x | tmp | ??)) |};}return tmp;
repeat
•Avoid copying and pasting repeat(n){ s} s;s;…s;
each of the n copies may resolve to a distinct stmt
n can be a hole too.
n
bit[W] tmp=0;repeat(??){ {| x | tmp |} = {| (!)?((x | tmp) (& | +) (x | tmp | ??)) |};}return tmp;
GENERATORS
User defined generators•Mechanism to define sets of code fragments
•They look like functions But with a few caveats
Key features of generators•Different dynamic invocations • different code
•Recursive generators = grammar of expressionsgenerator bit[W] gen(bit[W] x, int bnd){ assert bnd > 0; if(??) return x; if(??) return ??; if(??) return ~gen(x, bnd-1); if(??){ return {| gen(x, bnd-1) (+ | & | ^) gen(x, bnd-1) |}; }}
bit[W] isolate0sk (bit[W] x) implements isolate0 { return gen(x, 3);}
CONSTRAINT BASED SYNTHESIS PRIMER
Synthesis problem at the high level•Game theoretic view of synthesis
For every move of the environment
Synthesized program makes a counter move
The challenge of synthesis•For functions, the environment controls the inputs
i.e. whatever we synthesize must work for all inputs
•Modeled with a doubly quantified constraint
What does it mean to quantify over programs?
Quantifying over programs•Synthesis as curve fitting
we want a function that satisfies some properties
•It’s hard to do curve fitting with arbitrary curves Instead, people use parameterized families of curves Quantify over parameters instead of over functions
•A sketch is just a way of describing these families
31
InsightSketches are not arbitrary constraint systems
They express the high level structure of a program
A small number of inputs can be enough focus on corner cases
This is an inductive synthesis problem !
∃𝑐 ∀ 𝑖𝑛∈𝐸𝑄(𝑖𝑛 ,𝑐 )where E = {x1, x2, …, xk}
Insert your favorite checker here
CEGIS
{𝒊𝒏𝒊}
∃𝒄 𝒔 .𝒕 .𝑪𝒐𝒓𝒓𝒆𝒄𝒕 (𝑷 𝒄 , 𝒊𝒏𝒊) ∃ 𝒊𝒏𝒔 .𝒕 .¬𝑪𝒐𝒓𝒓𝒆𝒄𝒕 (𝑷𝒄 , 𝒊𝒏𝒊)
Synthesize Check𝒄
𝒊𝒏
•Constraints for each follow from semantics
Loops handled through simple unrolling
Insert your favorite checker here
CEGIS
{𝒊𝒏𝒊}
∃𝒄 𝒔 .𝒕 .𝑪𝒐𝒓𝒓𝒆𝒄𝒕 (𝑷 𝒄 , 𝒊𝒏𝒊)
Synthesize Check𝒄
𝒊𝒏