04/21/23 CS2104, Lecture 4 1

Programming Language Concepts, COSC-3308-01Lecture 4  

Procedures, last call optimization

04/21/23 CS2104, Lecture 4 2

Reminder of the last lecture Kernel language

linguistic abstraction data types variables and partial values statements and expressions

Kernel language semantics Use operational semantics

Aid programmer in reasoning and understanding The model is a sort of an abstract machine, but leaves out

details about registers and explicit memory address Aid implementer to do an efficient execution on a real machine

04/21/23 CS2104, Lecture 4 3

Concepts

Single-assignment store Environment Semantic statement Execution state Computation (last lecture) Statements execution of:

skip and sequential composition variable declaration store manipulation conditional

04/21/23 CS2104, Lecture 4 4

Overview Computing with procedures

lexical scoping closures procedures as values procedure call

Introduction of properties of the abstract machine last call optimization full syntax to kernel syntax

04/21/23 CS2104, Lecture 4 5

Procedures

Defining procedures how about external references? when and which variables matter?

Calling procedures what do the variables refer to? how to pass parameters? how about external references? where to continue the execution?

04/21/23 CS2104, Lecture 4 6

Identifiers in Procedures

P = proc {$ X Y}

if X>Y then Z=1 else Z=0 end

end

X and Y are called (formal) parameters Z is called an external reference

04/21/23 CS2104, Lecture 4 7

Identifiers in Procedures

proc {P X Y}

if X>Y then Z=1 else Z=0 end

end

X and Y are called (formal) parameters Z is called an external reference

More familiar variant

04/21/23 CS2104, Lecture 4 8

Free and Bound Identifiers

local Z in

if X>Y then Z=1 else Z=0 end

end

X and Y are free (variable) identifiers in this statement

Z is a bound (variable) identifier in this statement

04/21/23 CS2104, Lecture 4 9

Free and Bound Identifiers

local Z in

if X>Y then Z=1 else Z=0 end

end

X and Y are free variable identifiers in this statement (declared outside)

Z is a bound variable identifier in this statement (declared inside)

Declaration Occurrence

04/21/23 CS2104, Lecture 4 10

Free and Bound Occurrences

An occurrence of X is bound, if it is inside the body of either local, proc or case.

local X in …X… end

proc {$ …X…} in …X… end

case Y of f(X) then …X… end

An occurrence of X is free in a statement, if it is not a bound occurrence.

04/21/23 CS2104, Lecture 4 11

Free Identifiers and Free Occurrences Free occurrences can only exist in

incomplete program fragments, i.e., statements that cannot run.

In a running program, it is always true that every identifier occurrence is bound. That is, it is in closed-form.

04/21/23 CS2104, Lecture 4 12

Free Identifiers and Free Occurrences

A1=15

A2=22

B=A1+A2

The identifiers occurrences A1, A2, and B, are free.

This statement cannot be run.

04/21/23 CS2104, Lecture 4 13

Free Identifiers and Free Occurrences local A1 A2 in A1=15 A2=22 B=A1+A2 end

The identifier occurrences A1 and A2 are bound and the occurrence B is free.

This statement still cannot be run.

04/21/23 CS2104, Lecture 4 14

Free Identifiers and Free Occurrenceslocal B in

local A1 A2 in

A1=15

A2=22

B=A1+A2

end

{Browse B}

end This is in closed-form since it has no free identifier

occurrences. It can be executed!

04/21/23 CS2104, Lecture 4 15

Procedures

proc {Max X Y ?Z} % "?" is just a comment

if X>=Y then Z=X else Z=Y endend{Max 15 22 C}

When Max is called, the identifiers X, Y, and Z are bound to 15, 22, and the unbound variable referenced by C.

Can this code be executed?

04/21/23 CS2104, Lecture 4 16

Procedures

No, because Max and C are free identifiers!

local Max C in

proc {Max X Y ?Z}

if X>=Y then Z=X else Z=Y end

end

{Max 15 22 C}

{Browse C}

end

04/21/23 CS2104, Lecture 4 17

Procedures with external references proc {LB X ?Z} if X>=Y then Z=X else Z=Y end end

The identifier Y is not one of the procedure arguments.

Where does Y come from? The value of Y is taken when the procedure is defined.

This is a consequence of static scoping.

04/21/23 CS2104, Lecture 4 18

Procedures with external referenceslocal Y LB in Y=10 proc {LB X ?Z} if X>=Y then Z=X else Z=Y end end local Y=3 Z1 in {LB 5 Z1} endend Call {LB 5 Z} bind Z to 10. Binding of Y=3 when LB is called is ignored. Binding of Y=10 when the procedure is defined is

important.

04/21/23 CS2104, Lecture 4 19

Lexical Scoping or Static Scoping The meaning of an identifier like X is

determined by the innermost local statement that declares X.

The area of the program where X keeps this meaning is called the scope of X.

We can find out the scope of an identifier by inspecting the text of the program.

This scoping rule is called lexical scoping or static scoping.

04/21/23 CS2104, Lecture 4 20

Lexical Scoping or Static Scopinglocal X in

X=15

local X in

X=20

{Browse X}

end

{Browse X}

end

There is just one identifier, X, but at different points during the execution, it refers to different variables (x1

and x2).

E2={Xx2}E1 ={Xx1}

04/21/23 CS2104, Lecture 4 21

Lexical Scoping

local Z in

Z=1

proc {P X Y} Y=X+Z end

end A procedure value is often called a closure

because it contains an environment as well as a procedure definition.

04/21/23 CS2104, Lecture 4 22

Dynamic versus Static Scoping Static scope.

The variable corresponding to an identifier occurrence is the one defined in the textually innermost declaration surrounding the occurrence in the source program.

Dynamic scope. The variable corresponding to an identifier

occurrence is the one in the most-recent declaration seen during the execution leading up to the current statement.

04/21/23 CS2104, Lecture 4 23

Dynamic scoping versus static scopinglocal P Q in proc {Q X} {Browse stat(X)} end proc {P X} {Q X} end local Q in proc {Q X} {Browse dyn(X)} end {P hello} endend

What should this display, stat(hello) or dyn(hello)? Static scoping says that it will display stat(hello),

because P uses the version of Q that exists at P’s definition.

04/21/23 CS2104, Lecture 4 24

Contextual Environment

When defining procedure, construct

contextual environment maps all external references… …to values at the time of definition

Procedure definition creates a closure pair of procedure and contextual environment this closure is written to store

04/21/23 CS2104, Lecture 4 25

Example of Contextual Environmentlocal Inc in

local Z = 1 in proc {Inc X Y} Y = X + Z end local Y in {Inc 2 Y} {Browse Y} end end local Z = 2 in local Y in {Inc 2 Y}

{Browse Y} end endend

The first part (red colour) {Inc X} will be

bound to the value X+1 because Z is bound to 1

Display: 3 The second part

(blue colour) {Inc X} is still

bound to the value X+1

Display: 3

04/21/23 CS2104, Lecture 4 26

Environment Projection (last lecture) Given: Environment E

E | {x1, …, xn}

is new environment E’ where only mappings for {x1, …, xn} are retained from E

04/21/23 CS2104, Lecture 4 27

Procedure Declaration

Semantic statement is

(proc {x y1 … yn} s end, E)

Formal parameters y1, …, yn

External references z1, …, zm

Contextual environment

CE = E | {z1, …, zm}

04/21/23 CS2104, Lecture 4 28

Procedure Declaration

Semantic statement is

(proc {x y1 … yn} s end, E)

with E(x) = x

Create procedure value (closure or lexically scoped closure)

(proc {$ y1 … yn} s end,

E | {z1, …, zm})

in the store and bind it to x

04/21/23 CS2104, Lecture 4 29

Procedure Call

Values for external references actual parameters (actual arguments)

must be available to called procedure (“callee”) As usual: construct new environment

start from contextual environment for external references

adjoin actual parameters

04/21/23 CS2104, Lecture 4 30

Procedure Call Semantic statement is

({x y1 … yn}, E)

where E(x) is to be called y1, …, yn are actual parameters (arguments) E(y1), …, E(yn) are actual entities (values)

Activation condition E(x) is determined

04/21/23 CS2104, Lecture 4 31

Procedure Call Semantic statement is

({x y1 … yn}, E)

If the activation condition is false, then suspend the execution

If E(x) is not a procedure value, then raise an error

If E(x) is a procedure value, but with different number of arguments (≠ n), then raise an error

04/21/23 CS2104, Lecture 4 32

Procedure Call

If semantic statement is

({x y1 … yn}, E)

with

E(x) = (proc {$ w1…wn} s end, CE)

then push

(s, CE + {w1E(y1), …, wnE(yn)})

04/21/23 CS2104, Lecture 4 33

Executing a Procedure Call

(proc {$ w1…wn} s end, CE)

ST

+ +

If the activation condition “E(x) is determined” is true if E(x) matches ({x y1 … yn}, E)

(s, CE + {w1E(y1),

…, wnE(yn)})

ST

04/21/23 CS2104, Lecture 4 34

Summary so far Procedure values

go to store combine procedure body and contextual environment contextual environment defines external references contextual environment is defined by lexical scoping

Procedure call checks for the right type passes arguments by environments contextual environment for external references

04/21/23 CS2104, Lecture 4 35

Simple Example

local P in local Y in local Z in

Z=1

proc {P X} Y=X end

{P Z}

end end end

We shall reason that X, Y and Z will be bound to 1

04/21/23 CS2104, Lecture 4 36

Simple Example

local P Y Z in

Z=1

proc {P X} Y=X end

{P Z}

end

We will cheat: do all declarations in one step real implementations cheat as well…

Exercise: Define the execution of a local statement that introduces multiple variables simultaneously

04/21/23 CS2104, Lecture 4 37

Simple Example

([(local P Y Z in Z=1

proc {P X} Y=X end

{P Z}

end, )],

)

Initial execution state

04/21/23 CS2104, Lecture 4 38

Simple Example

([(local P Y Z in Z=1

proc {P X} Y=X end

{P Z}

end, )],

)

Statement

04/21/23 CS2104, Lecture 4 39

Simple Example

([(local P Y Z in Z=1

proc {P X} Y=X end

{P Z}

end, )],

)

Empty environment

04/21/23 CS2104, Lecture 4 40

Simple Example

([(local P Y Z in Z=1

proc {P X} Y=X end

{P Z}

end, )],

)

Semantic statement

04/21/23 CS2104, Lecture 4 41

Simple Example

([(local P Y Z in Z=1

proc {P X} Y=X end

{P Z}

end, )],

)

Semantic stack

04/21/23 CS2104, Lecture 4 42

Simple Example

([(local P Y Z in Z=1

proc {P X} Y=X end

{P Z}

end, )],

)

Empty store

04/21/23 CS2104, Lecture 4 43

Simple Example: local

([(local P Y Z in Z=1

proc {P X} Y=X end

{P Z}

end, )],

)

Create new store variables Extend the environment

04/21/23 CS2104, Lecture 4 44

Simple Example

([(Z=1 proc {P X} Y=X end

{P Z}, {Pp, Yy, Zz})],

{p, y, z})

04/21/23 CS2104, Lecture 4 45

Simple Example

([(Z=1 proc {P X} Y=X end

{P Z}, {Pp, Yy, Zz})],

{p, y, z})

Split sequential composition

04/21/23 CS2104, Lecture 4 46

Simple Example

([(Z=1, {Pp, Yy, Zz}),

(proc {P X} Y=X end {P Z}, {Pp, Yy, Zz})],

{p, y, z})

Split sequential composition

04/21/23 CS2104, Lecture 4 47

Simple Example

([(proc {P X} Y=X end {P Z}, {Pp, Yy, Zz})],

{p, y, z=1})

Variable-value assignment

04/21/23 CS2104, Lecture 4 48

Simple Example

([(proc {P X} Y=X end, {Pp, Yy, Zz}),

({P Z}, {Pp, Yy, Zz})],

{p, y, z=1})

Split sequential composition

04/21/23 CS2104, Lecture 4 49

Simple Example

([(proc {P X} Y=X end, {Pp, Yy, Zz}),

({P Z}, {Pp, Yy, Zz})],

{p, y, z=1})

Procedure definition external reference Y formal argument X

Contextual environment {Yy} Write procedure value to store

04/21/23 CS2104, Lecture 4 50

Simple Example

([({P Z}, {Pp, Yy, Zz})], { p = (proc {$ X} Y=X end, {Yy}),

y, z=1})

Procedure call: use p Note: p is a value like any other variable. It is the

semantic statement (proc {$ X} Y=X end, {Yy}) Environment

start from {Y y} adjoin {X z}

04/21/23 CS2104, Lecture 4 51

Simple Example

([(Y=X, {Yy, Xz})],

{ p = (proc {$ X} Y=X end, {Yy}), y, z=1})

Variable-variable assignment Variable for Y is y Variable for X is z

04/21/23 CS2104, Lecture 4 52

Simple Example

([],

{ p = (proc {$ X} Y=X end, {Yy}), y=1, z=1})

Voila! The semantic stack is in the run-time state

terminated, since the stack is empty

04/21/23 CS2104, Lecture 4 53

Discussion

Procedures take the values upon definition Application automatically restores them Not possible in Java, C, C++

procedure/function/method just code environment is lacking Java needs an object to do this one of the most powerful concepts in computer

science pioneered in Algol 68

04/21/23 CS2104, Lecture 4 54

Summary so far

Procedures are values as anything else! Will allow breathtaking programming

techniques With environments it is easy to understand

what is the value for an identifier

04/21/23 CS2104, Lecture 4 55

Properties of theAbstract Machine

04/21/23 CS2104, Lecture 4 56

What Can We Use the Abstract Machine for? Proving properties Understanding runtime Understanding memory requirements

Abstract Machine is a model for computation implementations will refine model

04/21/23 CS2104, Lecture 4 57

Exploiting the Abstract Machine We can define runtime of a statement s

the number of execution steps to execute s

We can understand how much memory execution requires semantic statements on the semantic stack number of nodes in the store

What is really in the store?

04/21/23 CS2104, Lecture 4 58

Exploiting the Abstract Machine We can proof:

local X in local Y in s end end

executes the same as

local Y in local X in s end end

04/21/23 CS2104, Lecture 4 59

Garbage Collection

A store variable x is alive, iff a semantic statement refers to x (occurs in

environment), or there exists an alive store variable y and y is bound

to a data structure containing x

All data structures which are not alive can be safely removed by garbage collection happens from time to time

04/21/23 CS2104, Lecture 4 60

Last Call Optimization

04/21/23 CS2104, Lecture 4 61

How Does Recursion Work?

local P in

P = proc {$} {P} end

{P}

end

Program will run forever Contextual environment of P will map P to

procedure value

04/21/23 CS2104, Lecture 4 62

04/21/23 CS2104, Lecture 4 63

Recursion at Work

([(local P in P = proc {$} {P} end

{P}

end, )], ) Initial state

04/21/23 CS2104, Lecture 4 64

Recursion at Work

([(P = proc {$} {P} end {P}, {Pp})], {p})

After execution of local

04/21/23 CS2104, Lecture 4 65

Recursion at Work

([(P = proc {$} {P} end, {Pp}), ({P}, {Pp})], {p})

After execution of sequential composition

04/21/23 CS2104, Lecture 4 66

Recursion at Work

([({P}, {Pp})], {p=(proc {$} {P} end, {Pp})})

After execution of procedure definition external reference of body of P: P contextual environment: {Pp}

04/21/23 CS2104, Lecture 4 67

Recursion at Work

([({P}, {Pp})], {p=(proc {$} {P} end, {Pp})})

After execution of procedure definition external reference of body of P: P contextual environment: {Pp}

Environment creates self reference

04/21/23 CS2104, Lecture 4 68

Recursion at Work

([({P}, {Pp})], {p=(proc {$} {P} end, {Pp})})

Will continue forever Stack will never grow! Runs in constant space

called iterative computation

04/21/23 CS2104, Lecture 4 69

Another Spinning Program

local Q in

Q = proc {$} {Q} {Q} end

{Q}

end Program will run forever Contextual environment of Q will map Q to

procedure value

04/21/23 CS2104, Lecture 4 70

Some Steps…

([({Q}, {Qq})], {q=(proc {$} {Q} {Q} end, {Qq})})

After execution of local sequential composition procedure definition

04/21/23 CS2104, Lecture 4 71

Procedure Call (1)

([({Q}, {Qq}), ({Q}, {Qq})], {q=(proc {$} {Q} {Q} end, {Qq})})

After execution of procedure call no arguments new environment is the same

contextual environment + argument environment {Qq} { }

04/21/23 CS2104, Lecture 4 72

Procedure Call (2)

([({Q}, {Qq}), ({Q}, {Qq}), ({Q}, {Qq})], {q=(proc {$} {Q} {Q} end, {Qq})})

Stack grows with each step!

04/21/23 CS2104, Lecture 4 73

Recursion: Summary

Iterative computations run in constant space

This concept is also called last call optimization no space needed for last call in procedure body

04/21/23 CS2104, Lecture 4 74

Two Functions…

N+M =

fun {SADD N M} %% returns N+M for positive N %% Slow ADDition if N==0 then M else 1+{SADD N-1 M} endend

fun {FADD N M} %% returns N+M for positive N %% Fast ADDition if N==0 then M else {FADD N-1 M+1} endend

0)1(1

0

NifMN

NifM

04/21/23 CS2104, Lecture 4 75

Questions

Which one is faster?

Which one uses less memory?

Why?

How?

04/21/23 CS2104, Lecture 4 76

Answers…

Transform to kernel language

See how they compute

Answer the questions

04/21/23 CS2104, Lecture 4 77

Procedure: SADD

proc {SADD N M NM} if N==0 then NM=M else local N1 in N1=N-1 local NM1 in {SADD N1 M NM1} NM=1+NM1 end end endend

04/21/23 CS2104, Lecture 4 78

Procedure: SADDproc {SADD N M NM}

if N==0 then NM=M

else local N1 in

N1=N-1

local NM1 in

{SADD N1 M NM1}

NM=1+NM1

end

end

end

end

procedure call after recursive

call

04/21/23 CS2104, Lecture 4 79

How Does SADD Compute?

local X Y Z in

X=4 Y=3

proc {SADD …} … end

{SADD X Y Z}

end

04/21/23 CS2104, Lecture 4 80

Sketch for SADD

([({SADD X Y Z}, …)], …)

([({SADD N1 M NM1}, …),

(NM = 1 + NM1, …)], …)

([({SADD N1 M NM1},…),

(NM = 1 + NM1, …)

(NM = 1 + NM1, …)], …) …

04/21/23 CS2104, Lecture 4 81

Procedure: FADD

proc {FADD N M NM} if N==0 then NM=M else local N1 in local M1 in N1=N-1 M1=M+1 {FADD N1 M1 NM} end end endend

04/21/23 CS2104, Lecture 4 82

Procedure: FADD

proc {FADD N M NM} if N==0 then NM=M else local N1 in local M1 in N1=N-1 M1=M+1 {FADD N1 M1 NM} end end endend

recursive call is last call

04/21/23 CS2104, Lecture 4 83

Sketch for FADD

([({FADD X Y Z}, …)], …)

([({FADD N1 M1 NM}, …)], …)

([({FADD N1 M1 NM}, …)], …)

([({FADD N1 M1 NM}, …)], …) …

04/21/23 CS2104, Lecture 4 84

SADD versus FADD SADD uses stack space depending on its

argument

FADD uses constant stack space iterative computation thanks to last call optimization

Techniques for achieving iterative computations: accumulators (later)

04/21/23 CS2104, Lecture 4 85

Summary so far: Most Important Concepts Single-assignment variables

partial values Abstract machine

a tool for understanding computations a model of computation based on environments supports last call optimization

Procedures with contextual environment

04/21/23 CS2104, Lecture 4 86

Abstract Machine General approach to explain how a

programming language computes model for computation

Can serve as base for implementation pioneered by Prolog D.H.D. Warren,

1980’s many other languages including Oz recent: JVM (Java) SUN

CLR (C#, …) Microsoft

04/21/23 CS2104, Lecture 4 87

Goal

Programming as an engineering/scientific discipline

An engineer can understand abstract machine apply programming techniques develop replicate approach with abstract machine

programs and techniques

04/21/23 CS2104, Lecture 4 88

Summary Computing with procedures

lexical scoping closures procedures as values procedure call

Introduction of properties of the abstract machine last call optimization full syntax to kernel syntax

04/21/23 CS2104, Lecture 4 89

Reading suggestions

Chapter 2, Sections 2.4, 2.5, 2.6, 2.7 from [van Roy,Haridi; 2004]

Exercises 2.9.4-2.9.12 from [van Roy,Haridi; 2004]

04/21/23 CS2104, Lecture 4 90

Coming up next

Iteration, Recursion, Exceptions, Type Notation, and Design Methodology

Chapter 2, Sections 2.4, 2.5, 2.6, 2.7 from [van Roy,Haridi; 2004]

Chapter 3, Sections 3.2-3.9

04/21/23 CS2104, Lecture 4 91

Thank you for your attention!

Questions?