1 / 34

CS 655: Programming Languages

Lecture 2: Operational Semantics. CS 655: Programming Languages. “Then you should say what you mean,” the March Hare went on. “I do,” Alice hastily replied; “at least – at least I mean what I say – that’s the same thing, you know.”

baruch
Download Presentation

CS 655: Programming Languages

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Lecture 2: Operational Semantics CS 655: Programming Languages “Then you should say what you mean,” the March Hare went on. “I do,” Alice hastily replied; “at least – at least I mean what I say – that’s the same thing, you know.” “Not the same thing a bit!” said the Hatter. “Why, you might as well say that ‘I see what I eat’ is the same thing as ‘I eat what I see’!" Lewis Carrol, Alice in Wonderland “When I use a word,” Humpty Dumpty said, in a rather scornful tone, “it means just what I choose it to mean – neither more nor less.” Lewis Carroll, Through the Looking Glass David Evans Office 236A, 982-2218 evans@cs.virginia.edu http://www.cs.virginia.edu/~evans University of Virginia Computer Science

  2. Menu • Survey Summary • Position Papers Results • Intro to Formal Semantics • Operational Semantics CS 655: Lecture 2

  3. Students’ Experience C - 92.5 years, C++ - 78, BASIC 64, Pascal – 45, Java - 26.5, assemblies – 26, FORTRAN – 22, LISP – 17, Perl – 14.5 Ada, ADAMS, Common LISP, Delphi, Elf, Forth, Haskell, HP Calculator, Hypertalk, JavaScript (large system for DOD!), ksh, LOGO, ML, nawk, ObjectPal, Python, Prolog, REBOL, Relay Ladder Logic, Sather, Scheme, Smalltalk, SQL, Tcl/Tk CS 655: Lecture 2

  4. Position Paper 1 • No +, 5 +2 (= = 1.4…) • Our not favorite languages: BASIC (1) C (8 - 1) C++ (3) FORTRAN (2) Java (8 - 2) Perl (2 - 2) • Good papers had to get at underlying issues, not just symptoms • Some misconceptions about GC CS 655: Lecture 2

  5. Project Teams • You have until noon Monday to submit team requests • Use the discussion board if you are looking for teammates (link off ~cs655 page) CS 655: Lecture 2

  6. Formal Semantics CS 655: Lecture 2

  7. What does a program mean? • Compile and run • Implementation dependencies • Not useful for reasoning • Informal Semantics • Natural language description of PL • Formal Semantics • Description in terms of notation with formally understood meaning CS 655: Lecture 2

  8. Why not informal semantics? Two types have compatible types if their types are the same [footnote: Two types need not be identical to be compatible.]. ANSI C Standard, 3.1.2.6 CS 655: Lecture 2

  9. Formal Semantics Approaches • Operational • Map to execution of a virtual machine • Easier to understand, harder to reason about • Depends on informal understanding of machine • Denotational • Map parts to mathematical meanings, rules for composing meanings of pieces • Harder to understand, easier to reason about • Depends on informal understanding of mathematics • Lots of others: Algebraic, Translator, etc. CS 655: Lecture 2

  10. A Toy Language: BARK (Beginner’s All-Purpose Register Kode) Program ::= Instruction* Program is a sequence of instructions Instructions are numbered from 0. Instruction ::= STORELocLiteralLoc gets the value of Literal | ADDLoc1Loc2Loc1 gets the value of Loc1 + Loc2 | MULLoc1Loc2 Loc1 gets the value of Loc1 * Loc2 | HALT Stop program execution, answer in R0 | ERROR Stop program execution, error | GOTOLoc Jump to instruction corresponding to value in Loc. | IFLoc1THENLoc1 If value in Loc1 is non-zero, jump to instruction corresponding to value in Loc2. Loc::= R[-]?[0-9][0-9]* Literal ::= [-]?[0-9][0-9]* CS 655: Lecture 2

  11. A BARK Program [0] STORE R0 1 [1] STORE R1 10 [3] STORE R2 –1 [4] STORE R3 6 [5] STORE R4 8 [6] IF R1 THEN R4 [7] HALT [8] MUL R0 R1 [9] ADD R1 R2 [10] GOTO R3 CS 655: Lecture 2

  12. Operational Semantics Game Real World Abstract Machine Program Initial Configuration Input Function Intermediate Configuration Transition Rules Intermediate Configuration Answer Final Configuration Output Function CS 655: Lecture 2

  13. Structured Operational Semantics SOS for a language is five-tuple: CSet of configurations for an abstract machine  Transition relation (subset of C x C) I Program  C (input function) F Set of final configurations OF  Answer (output function) CS 655: Lecture 2

  14. Abstract Machine: Register Virtual Machine (RVM) Configuration defined by: • Array of Instructions • Program counter • Values in registers (any integer) C = Instructions x PC x RegisterFile …. …. Instruction[-1] Register[-1] Instruction[0] Register[0] PC Instruction[1] Register[1] Instruction[2] Register[2] …. …. CS 655: Lecture 2

  15. Input Function: I: Program  C C = Instructions x PC x RegisterFile where For a Program with n instructions numbered from 0 to n - 1:Instructions[m] = Program[m] for m >= 0 && m < n Instructions[m] = ERROR otherwise PC = 0 RegisterFile[n] = 0 for all integers n CS 655: Lecture 2

  16. Final Configurations Output Function F = Instructions x PC x RegisterFile where Instructions[PC] = HALT O:F  Answer Answer = value in RegisterFile[0] CS 655: Lecture 2

  17. Operational Semantics Game Real World Abstract Machine Program Initial Configuration Input Function Intermediate Configuration Transition Rules Intermediate Configuration Answer Final Configuration Output Function CS 655: Lecture 2

  18. Form of Transition Rules Antecedents c c’ Where c is a member of C . CS 655: Lecture 2

  19. STORELoc Literal Instructions[PC] = STORELoc Literal < Instructions x PC x RegisterFile >  < Instructions x PC’ x RegisterFile’ > where PC’ = PC + 1 RegisterFile’[n] = RegisterFile[n] if n  Loc RegisterFile’[n] = value of Literal if n  Loc CS 655: Lecture 2

  20. ADDLoc1 Loc2 Instructions[PC] = ADDLoc1 Loc2 < Instructions x PC x RegisterFile >  < Instructions x PC’ x RegisterFile’ > where PC’ = PC + 1 RegisterFile’[n] = RegisterFile[n] if n  Loc RegisterFile’[n] = RegisterFile[Loc2] if n  Loc1 CS 655: Lecture 2

  21. GOTOLoc Instructions[PC] = GOTOLoc < Instructions x PC x RegisterFile >  < Instructions x PC’ x RegisterFile > where PC’ = value in RegisterFile[Loc] CS 655: Lecture 2

  22. IFLoc1THEN Loc2 Instructions[PC] = IFLoc1THEN Loc2 < Instructions x PC x RegisterFile >  < Instructions x PC’ x RegisterFile > where PC’ = value in RegisterFile[Loc2] if Loc1 is non-zero PC’ = PC + 1 otherwise CS 655: Lecture 2

  23. What’s it good for? • Understanding programs • Write a compiler or interpreter (?) • Prove properties about programs and languages CS 655: Lecture 2

  24. Variation: BARK-forward Same as BARK except: GOTOLoc Jump forward Loc instructions. Loc must be positive. | IFLoc1THENLoc2 If value in Loc1 is non-zero, jump forward value in Loc2. instructions. Loc2 must be positive. CS 655: Lecture 2

  25. BARK: GOTOLoc < Instructions x PC x RegisterFile >  < Instructions x PC’ x RegisterFile > where PC’ = value in RegisterFile[Loc] Instructions[PC] = GOTOLoc Instructions[PC] = GOTOLoc,value in Loc > 0 < Instructions x PC x RegisterFile >  < Instructions x PC’ x RegisterFile > where PC’ = PC + value in RegisterFile[Loc] CS 655: Lecture 2

  26. Proving Termination • Idea: Prove by Induction • Define a function Energy: C  positive integer • Show Energy of all Initial Configurations is finite • Show there are no transitions from a configuration with Energy = 0 • If C  C’ is a valid transition step, Energy of C’ must be less than Energy of C CS 655: Lecture 2

  27. Energy Function Energy: C  positive integer C = < Instructions x PC x RegisterFile > Energy = h – PC where h is an integer such that Instructions[k] = error for all k >= h CS 655: Lecture 2

  28. Initial Configurations For all Initial Configurations C , Energy is finite. Consider Input Function: C = Instructions x PC x RegisterFile where For a Program with n instructions numbered from 0 to n - 1:Instructions[m] = Program[m] for m >= 0 && m < n Instructions[m] = ERROR otherwise PC = 0 RegisterFile[n] = 0 for all integers n CS 655: Lecture 2

  29. Initial Configuration Energy Energy (C ) = n where n is number of program instructions PC = 0 Instruction[m] = ERROR for m >= n CS 655: Lecture 2

  30. Energy = 0  Terminated Energy = h – PC where h is an integer such that Instructions[k] = error for all k >= h so, Energy = 0  h = PC and Instructions[PC] = ERROR No transitions for configuration where Instructions[PC] = ERROR CS 655: Lecture 2

  31. STORE reduces Energy Instructions[PC] = STORELoc Literal < Instructions x PC x RegisterFile >  < Instructions x PC’ x RegisterFile’ > where PC’ = PC + 1 RegisterFile’[n] = RegisterFile[n] if n  Loc RegisterFile’[n] = value of Literal if n  Loc Energy (<Instructions x PC x RegisterFile>) = h – PC Energy (<Instructions x PC’ x RegisterFile>) = h – (PC + 1) h depends only on Instructions, doesn’t change Therefore: Energy’ < Energy CS 655: Lecture 2

  32. GOTO reduces Energy Instructions[PC] = GOTOLoc,value in Loc > 0 < Instructions x PC x RegisterFile >  < Instructions x PC’ x RegisterFile > where PC’ = PC + value in RegisterFile[Loc] Energy(<Instructions x PC x RegisterFile>) = h - PC Energy(<Instructions x PC’ x RegisterFile>) = h – (PC + RegisterFile[Loc]) but antecedent says RegisterFile[Loc] > 0, so PC + RegisterFile[Loc] > PC and Energy’ < Energy. CS 655: Lecture 2

  33. To complete proof… • Show the same for every transition rule. • Then: • Start with finite energy, • Every transition reduces energy, • Energy must eventually reach 0. • And energy 0 means we terminated. • Minor flaw? could skip 0 (e.g., Energy = –1) CS 655: Lecture 2

  34. Charge • Problem Set 1: • Develop Operational Semantics for simplified PostFix using RVM • Prove termination property • Final project team requests by Monday • Next time: • Projects • Discuss Wenger paper: come to class prepared to discuss how well his milestones work today CS 655: Lecture 2

More Related