david evans cs.virginia/~evans

David Evanshttp://www.cs.virginia.edu/~evans

CS655: Programming LanguagesUniversity of VirginiaComputer Science

Lecture 13: Operational Semantics

“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

1 March 2001 CS 655: Lecture13 2

Menu

• Quiz Results• Intro to Formal Semantics• Operational Semantics


Quiz Results• Preferences

– Mostly formal techniques x– Balanced xx– Mostly language design xxxxx– Just language design xx

• Mock Trial– Heard about Yes 6 No 3

Yes, very 1 Yes 2

Maybe 1.5No, research 0.5No, sleeping 1

• Speed: way too fast (0), too fast (6), wrote in just right/both (3), too slow (1)


Other Comments“disappointed to hear that there were no more

programming assignments...I’d be interested in playing with and analyzing languages like Smalltalk, CLU, and APL...”

“though I’ve found a good deal of the material interesting, I don’t necessarily feel entirely prepared to write a Why X is not my favorite Programming Language”

“I’m tired of Scheme...mostly because the MIT scheme interpreter is poorly written and doesn’t allow you to easily perform editing operations...”

Run M-x scheme in emacs


Other Comments“complaint is that we’re doing homework on old stuff that is no longer focused on in class, making it difficult for me to devote my energies to the new stuff.”“hasn’t taken the approach I would’ve expected – such as covering PL concepts (types, binding, etc.) in the context of a range of languages”“hope we can get lectures before class, so that we can have some preparation before class, ..., and take some notes beside the lectures.”“there are too many readings. I don’t have enough time to read them all.” (also checked “Mostly language design and history”)


Find a Lambda calculus term that has a normal form, but that will not be reduced to that form if beta reductions are not done in normal order.

Like asking: “Find a Scheme program that terminates with lazy evaluation, but doesn’t terminate with eager evaluation. Translate it into Lambda calculus.”


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


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


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.• What about Lambda Calculus?


A Toy Language: BARK

Program ::= Instruction* Program is a sequence of instructionsInstructions are numbered from 0.

Instruction ::= STORE Loc Literal Loc gets the value of Literal

| ADD Loc1 Loc2 Loc1 gets the value of Loc1 + Loc2

| MUL Loc1 Loc2 Loc1 gets the value of Loc1 * Loc2

| HALT Stop program execution, answer in R0 | ERROR Stop program execution, error | GOTO Loc Jump to instruction corresponding to

value in Loc. | IF Loc1 THEN Loc1 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]*

(Beginner’s All-Purpose Register Kode)


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


Operational Semantics Game

Input Function

Abstract Machine

InitialConfiguration

FinalConfiguration

Output FunctionAnswer

IntermediateConfiguration


TransitionRules

Real World

Program


Structured Operational Semantics

SOS for a language is five-tuple:

C Set of configurations for an abstract machine

Transition relation (subset of C x C)I Program C (input function)F Set of final configurationsO F Answer (output function)


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[0]

Instruction[1]

Instruction[2]

….

Instruction[-1]

….

PC

Register[0]

Register[1]

Register[2]

….

Register[-1]

….


Input Function: I: Program CC = Instructions x PC x RegisterFile whereFor 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 = 0RegisterFile[n] = 0 for all integers n


Final ConfigurationsF = Instructions x PC x RegisterFile

where Instructions[PC] = HALT

Output FunctionO:F AnswerAnswer = value in RegisterFile[0]


Operational Semantics Game

Input Function

Abstract Machine

InitialConfiguration

FinalConfiguration

Output FunctionAnswer



TransitionRules

Real World

Program


Form of Transition Rules

Antecedents

c c’

Where c is a member of C .


STORE Loc Literal

Instructions[PC] = STORE Loc Literal

< Instructions x PC x RegisterFile > < Instructions x PC’ x RegisterFile’ >where

PC’ = PC + 1RegisterFile’[n] = RegisterFile[n] if n LocRegisterFile’[n] = value of Literal if n Loc


ADD Loc1 Loc2

Instructions[PC] = ADD Loc1 Loc2


PC’ = PC + 1RegisterFile’[n] = RegisterFile[n] if n LocRegisterFile’[n] = RegisterFile[Loc2] if n Loc1


GOTO Loc

Instructions[PC] = GOTO Loc

< Instructions x PC x RegisterFile > < Instructions x PC’ x RegisterFile > where PC’ = value in RegisterFile[Loc]


IF Loc1 THEN Loc2

Instructions[PC] = IF Loc1 THEN Loc2

< Instructions x PC x RegisterFile > < Instructions x PC’ x RegisterFile > where

PC’ = value in RegisterFile[Loc2] if Loc1 is non-

zeroPC’ = PC + 1 otherwise


What’s it good for?

• Understanding programs• Write a compiler or interpreter (?)• Prove properties about programs and

languages


Variation: BARK-forward

Same as BARK except:GOTO Loc Jump forward Loc instructions. Loc must

be positive. | IF Loc1 THEN Loc2 If value in Loc1 is non-zero, jump

forwardvalue in Loc2. instructions. Loc2

must be positive.


GOTO Loc Instructions[PC] = GOTO Loc

< Instructions x PC x RegisterFile > < Instructions x PC’ x RegisterFile > where PC’ = value in RegisterFile[Loc]

BARK:

Instructions[PC] = GOTO Loc,value in Loc > 0

< Instructions x PC x RegisterFile > < Instructions x PC’ x RegisterFile > where

PC’ = PC + value in RegisterFile[Loc]


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


Energy Function

Energy: C positive integerC = < Instructions x PC x RegisterFile > Energy = h – PC where

h is an integer such that Instructions[k] = error for all k >= h


Initial ConfigurationsFor all Initial Configurations C , Energy is

finite. Consider Input Function:

C = Instructions x PC x RegisterFile whereFor 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 = 0RegisterFile[n] = 0 for all integers n


Initial Configuration Energy

Energy (C ) = nwhere n is number of program instructions

PC = 0Instruction[m] = ERROR for m >= n


Energy = 0 Terminated

Energy = h – PC whereh 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


STORE reduces EnergyInstructions[PC] = STORE Loc Literal


PC’ = PC + 1RegisterFile’[n] = RegisterFile[n] if n LocRegisterFile’[n] = value of Literal if n Loc

Energy (<Instructions x PC x RegisterFile>) = h – PCEnergy (<Instructions x PC’ x RegisterFile>) = h – (PC + 1)h depends only on Instructions, doesn’t changeTherefore: Energy’ < Energy


GOTO reduces EnergyInstructions[PC] = GOTO Loc,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 - PCEnergy(<Instructions x PC’ x RegisterFile>) =

h – (PC + RegisterFile[Loc])but antecedent says RegisterFile[Loc] > 0,so PC + RegisterFile[Loc] > PCand Energy’ < Energy.


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)


Charge

• Gifford’s Ch 3 uses a stack-based virtual machine to provide an operational semantics for a stack-based language

• Next time:– Projects Kickoff – start thinking about things you

want to do– Types and Static Semantics

david evans cs.virginia/~evans

Documents

compatible types

x scheme

scheme program

pl concepts types

mit scheme interpreter

programming assignments

normal form

looking glass cs