SPT: Storyboard Programming Tool

Transcription

1 SPT: Storyboard Programming Too The MIT Facuty has made this artice openy avaiabe. Pease share how this access beneits you. Your story matters. Citation As Pubished Pubisher Singh, Rishabh, and Armando Soar-Lezama. SPT: Storyboard Programming Too. Lecture Notes in Computer Science (2012): Springer-Verag Version Author's ina manuscript Accessed Sun Oct 07 11:20:09 EDT 2018 Citabe Link Terms o Use Creative Commons Attribution-Noncommercia-Share Aike Detaied Terms

2 SPT: Storyboard Programming Too Rishabh Singh and Armando Soar-Lezama MIT CSAIL, Cambridge, MA, USA Abstract. We present Spt, a too that heps programmers write oweve data-structure manipuations by combining various orms o insights such as abstract and concrete input-output eampes as we as impementation skeetons. When programmers write such manipuations, they typicay have a cear high-eve intuition about how the manipuation shoud work, but impementing eicient ow-eve pointer manipuating code is error-prone. Our too aims to bridge the gap between the intuition and the corresponding impementation by automaticay synthesizing the impementation. The too rames the synthesis probem as a generaization o an abstract-interpretation based shape anaysis, and represents the probem as a set o constraints which are soved eicienty by the Sketch sover. We report the successu evauation o our too on synthesizing severa inked ist and binary search tree manipuations. 1 Introduction When programmers write data-structure manipuations, they typicay have cear high-eve visua insights about how the manipuation shoud work, but the transation o these insights to eicient ow-eve pointer manipuating code is diicut and error prone. Program synthesis [1, 5, 6] oers an opportunity to improve productivity by automating this transation. This paper describes our too Spt 1 (Storyboard Programming Too) that heps programmers write ow-eve impementations o data-structure manipuations by combining various orms o insights, incuding abstract and concrete input-output eampes as we as impementation skeetons. Our too is based on a new synthesis agorithm [4] that combines abstractinterpretation based shape-anaysis [2, 3] with constraint-based synthesis [5, 7, 8]. The agorithm uses an abstraction reinement based approach to concisey encode synthesis constraints obtained rom shape anaysis. In this paper, we present a high-eve storyboard anguage that aows programmers to succincty epress the dierent eements that make up a storyboard. The anguage is more concise than the one described in [4] thanks to the use o inerence to derive many ow-eve detais o the storyboard. The paper aso describes the architecture o the Storyboard Programming Too and presents some new resuts comparing Spt with the Sketch synthesis system. Supported by NSF under grant CCF The Storyboard too and benchmarks are avaiabe or downoad at

3 2 Overview: Linked List deetion We present an overview o our too using inked ist deetion as a running eampe. The goa o this manipuation is to deete a node pointed to by a variabe y rom an acycic singy inked ist. The manipuation iterates over the ist unti it inds the required node and then perorms a sequence o pointer assignments to deete the node. Spt synthesizes an imperative impementation o deetion rom a high-eve storyboard in about two minutes. The storyboard that Spt takes as input is composed o scenarios, inductive deinitions and a oop skeeton. A scenario describes the (potentiay abstract) state o a data-structure at dierent stages o the manipuation. Each scenario contains at east two conigurations: input and output corresponding to the state o the data-structure beore and ater the manipuation; a scenario may aso contain descriptions o the state at intermediate points in the computation. The scenarios or inked ist deetion are shown in Figure 1(a), and the corresponding visua description o the scenarios is shown in Figure 1(b). The irst scenario s1 describes an abstract input-output eampe, where the input ist consists o two summary nodes ront and back and a concrete node y that is to be deeted. In this case, the summary node serves as an abstract representation o a ist o arbitrary size. In genera, a summary node represents an arbitrary set o nodes; those nodes in the set which are connected to other nodes not in the set are given concrete names and are caed attachment points. The summary node ront contains two attachment points ront:: and ront:: denoting the irst and ast eements o the ront ist respectivey. The state conigurations are deined using a ist o state predicates such as ( -> ront::) which denotes that the variabe points to the attachment point o ront. The other scenarios s2, s3 and s4 correspond to the cases o deeting the ast node, the irst node and the ony node o the ist respectivey. Notice that there is no scenario corresponding to the case where the node to be deeted is not in the ist. That means that the behavior o the synthesized code wi be unspeciied in such a case. In order or the synthesizer to reason about summary nodes, the user needs to speciy their structure. In this case, or eampe, the user needs to epress the act that ront and back are not just arbitrary sets o nodes; they are ists. In Spt, this structura inormation is provided inductivey through unod rues. The two possibe unod rues or the summary node ront and their corresponding visua description are shown in Figure 2. The rue states that the summary node ront either represents a singe node or a node oowed by another simiar summary node ront. The unod predicate consists o the summary node, the repacement node, the incoming and outgoing edges, and additiona constraints that hod ater the unod operation. In Spt, the programmer can aso provide od rues to describe to the system how sets o nodes can be summarized by a singe node. In most cases, such as the eampe, the synthesizer can reason about the correctness o a manipuation by using the inverse o the unod rues or summarization, but or some tree agorithms, the synthesis process can be made more eicient by providing epicit od rues or summarization.

4 scenario s1 input: -> ront::, y -> y ront::. -> y, back:: -> nu, y. -> back:: output: -> ront::, ront::. -> back::, back::. -> nu scenario s2 input: -> ront::, y -> y y. -> nu, ront::. -> y output: -> ront::, ront::. -> nu scenario s3 input: -> y,y. -> back::, y -> y, back::. -> nu output: -> back::, back::. -> nu scenario s4 input: -> y,y. -> nu,y -> y output: -> nu y ront back y s1 ront back y back y s3 back y ront y s2 ront y y s4 (a) (b) Fig. 1. Scenarios describing input and output state descriptions or inked ist deetion. ront ront ront ront unod ront:: [in (ront::, )] [out (ront::, )] () unod ront:: [in (ront::, )] [out (ront::, ront::)] (. -> ront::) unod ront:: [in (ront::, )] [out (ront::, )] () unod ront:: [in (ront::, ront::)] [out (ront::, )] (ront::. -> ) Fig. 2. Two possibe unod deinitions or summary node ront. In addition to the scenario descriptions, Spt aso requires users to provide a oop skeeton o the desired impementation. This heps the synthesizer ocus on impementations that are cose to the user s epectations, and aso ets them speciy intermediate state constraints. The oop skeeton or the running eampe is shown in Figure 3(a). It consists o a whie oop with a set o unknown statements beore the oop, in the oop body and ater the oop. The unknown statements are denoted by the??(n) operator, where n represents the maimum ength o the unknown statement bock. Spt restricts unknown statements to be o two orms: i) guarded statements o the orm i(**) then ASSIGN, where ** represents a conditiona over pointer variabes and ASSIGN denotes pointer assignments with at most one pointer dereerence, and ii) unod/od statements o the orm unod var (resp. od var) that corresponds to unoding (oding) the ocation pointed to by variabe var.

5 Deete(Node, Node y){ Node temp, prev;??(2) /* h1 */ whie(**){ /* h2 */??(4) /* h3 */??(2) /* h4 */ Deete(Node, Node y){ Node temp, prev; temp = ; whie(temp!= y){ // unod temp1; prev = temp; temp = temp.; // od prev; i(prev == nu) = temp.; i(prev!= nu) prev. = temp.; insert(node, Node y) { Node temp1, temp2;??(2) /* h1 */ whie(**){ /* h2 */??(4) /* h3 */ /* position o y ound */ yposfound:??(4) /* h4 */ (a) (b) (c) Fig. 3. (a) The oop skeeton and (b) the synthesized impementation or inked ist deetion and (c) the oop skeeton or sorted inked ist insertion. Given the scenarios, recursive deinitions and the oop skeeton, Spt synthesizes the imperative impementation shown in Figure 3(b). The true conditionas and skip statements are removed rom the code or better readabiity. 3 Agorithm The detais o the synthesis agorithm used by Spt can be ound in [4]. At a high eve, the agorithm irst transates the oop skeeton into a set o equations reating the inputs and outputs o a the unknown bocks o code. Let F i denote the unknown transer unction that maps a set o program states to another set o program states. The reationships between the inputs and outputs o a the transer unctions is captured by a set o equations o the orm: (t 0 = In k ) vi (V \v 0) t i = F i ( t j ) (1) j pred(v i) where pred(v i ) denotes the predecessors o node v i in the cg. In k denotes the input state constraint or the k th scenario, and the goa is to ind F i such that t N = Out k or each scenario k. The system works by representing the F i as parameterized unctions and soving or the parameters by using a countereampe guided inductive synthesis [4]. 4 Too Architecture The architecture o Storyboard Programming Too consists o our major components as shown in Figure 4: A. Storyboard Parser: The parser takes as input a storyboard description ( *.sb) written in the storyboard anguage and transates it into our intermediate constraint anguage that consists o a set o proog predicates ( *.p). The

6 STORYBOARD PROGRAMMING TOOL C impementation.c.sb input storyboard A STORYBOARD PARSER.p D CODE GENERATOR.out B CONSTRAINT GENERATOR.sk C SKETCH SOLVER Fig. 4. The architecture o Storyboard Programming Too. storyboard anguage is more concise than [4] because the parser aso perorms some type inerence to iner variabes, ocations, seectors, and summary nodes. B. Constraint Generator: The constraint generator transates the proog predicates into a sketch constraint ie ( *.sk). Sketch provides an epressive anguage to deine the shape anaysis probem, aowing us to use high-eve anguage constructs such as unctions, arrays and structures to mode the abstract state, as we as hoes to mode the unknown transer unctions. The probem is encoded in a way that everages the countereampe guided inductive synthesis agorithm o sketch to avoid having to represent sets o shapes epicity. C. Sketch Sover: The Sketch sover soves the sketch constraint ie and produces an output (.out) ie where a unknown unction choices are resoved. D. Code Generator: The code generator takes as input the output generated by the Sketch sover and competes the oop skeeton (.c) by mapping the unction choice vaues to their corresponding program statements and conditionas using the intermediate constraint ie ( *.p). 5 Eperiments and Too Eperiences We evauated the too on severa inked ist and binary search tree manipuations as we as AIG (And-Inverter Graph) insertion. The detais about the eperiments and benchmarks can be ound in [4]. We present here a comparison with the Sketch too on a sma sampe o benchmarks. Comparison with Sketch: Tabe 1 shows the running times o the Storyboard too with the Sketch system. We can see that Sketch is aster, but can ony perorm bounded reasoning (N=5) and quicky times out or arger vaues o N. On the other hand, the storyboard too perorms unbounded anaysis using abstract interpretation. However, the biggest dierence we ound was in the usabiity o the toos. We had to spend amost three hours or writing a spec in Sketch or these manipuations. For writing a sketch, one has to write a converter (and its inverse) or converting (resp. transating back) an array to that

7 Benchmark Sketch Storyboard (N=5) -reverse 18s 1m40s -insert 31s 2m3s -deete 25s 2m8s bst-search 39s 2m51s bst-insert 3m35s 3m12s Tabe 1. Perormance comparison with Sketch. data structure. Then one has to use quantiied input variabes or writing tricky specs. In our storyboard too, we ony have to provide input-output eampes which in our eperience was a ot more natura. We now present some o our other eperiences in handing compicated manipuations with the too. Intermediate State Conigurations: Our too aows users to write intermediate state conigurations to reduce the search space and enabe the synthesizer to synthesize more compe manipuations. The user can abe a program ocation in the oop skeeton and provide the state description at that point using the intermediate keyword as part o the scenario description. For eampe in the case o insertion in a sorted inked ist, we add an additiona insight based on the act that the oop skeeton or the insertion (Figure 3(c)) is perorming two tasks: irst to ind a suitabe ocation or inserting the node y and the second task o inserting y into the ist. In the abstract scenario, we provide an intermediate state coniguration at the abe yposfound in which two variabes point to the two ocations between which the insertion is to be perormed. The Spt too iustrates a new approach to synthesis namey Mutimoda Synthesis, where the synthesizer takes input speciication in many dierent orms such as concrete eampes, abstract eampes, and impementation insights, and synthesizes code that is provaby consistent with a o them. We beieve this idea o mutimoda synthesis has appicabiity in many other domains as we. Reerences 1. B. Jobstmann, A. Griesmayer, and R. Boem. Program repair as a game. In CAV, pages , T. Lev-Ami and S. Sagiv. TVLA: A system or impementing static anayses. In SAS, pages , M. Sagiv, T. Reps, and R. Wihem. Parametric shape anaysis via 3-vaued ogic. In POPL, pages , R. Singh and A. Soar-Lezama. Synthesizing data structure manipuations rom storyboards. In FSE, pages , A. Soar-Lezama. Program Synthesis By Sketching. PhD thesis, EECS, UC Berkeey, A. Soar-Lezama, R. Rabbah, R. Bodik, and K. Ebciogu. Programming by sketching or bit-streaming programs. In PLDI, pages , S. Srivastava, S. Guwani, and J. S. Foster. From program veriication to program synthesis. In POPL, pages , M. T. Vechev, E. Yahav, and G. Yorsh. Abstraction-guided synthesis o synchronization. In POPL, pages , 2010.