Transcript Slide 1

Programming Language Concepts,
COSC-3308-01
Lecture 4
Procedures, last call optimization
7/17/2015
CS2104, Lecture 4
1
Reminder of the last lecture

Kernel language





linguistic abstraction
data types
variables and partial values
statements and expressions
Kernel language semantics

Use operational semantics


The model is a sort of an abstract machine, but leaves out
details about registers and explicit memory address

7/17/2015
Aid programmer in reasoning and understanding
Aid implementer to do an efficient execution on a real machine
CS2104, Lecture 4
2
Concepts






Single-assignment store
Environment
Semantic statement
Execution state
Computation
(last lecture) Statements execution of:




7/17/2015
skip and sequential composition
variable declaration
store manipulation
conditional
CS2104, Lecture 4
3
Overview

Computing with procedures





lexical scoping
closures
procedures as values
procedure call
Introduction of



7/17/2015
properties of the abstract machine
last call optimization
full syntax to kernel syntax
CS2104, Lecture 4
4
Procedures

Defining procedures



how about external references?
when and which variables matter?
Calling procedures




7/17/2015
what do the variables refer to?
how to pass parameters?
how about external references?
where to continue the execution?
CS2104, Lecture 4
5
Identifiers in Procedures
P = proc {$ X Y}
if X>Y then Z=1 else Z=0 end
end


and Y are called (formal) parameters
Z is called an external reference
X
7/17/2015
CS2104, Lecture 4
6
Identifiers in Procedures
proc {P X Y}
if X>Y then Z=1 else Z=0 end
end

and Y are called (formal) parameters
Z is called an external reference

More familiar variant

X
7/17/2015
CS2104, Lecture 4
7
Free and Bound Identifiers
local Z in
if X>Y then Z=1 else Z=0 end
end


and Y are free (variable) identifiers in this
statement
Z is a bound (variable) identifier in this
statement
X
7/17/2015
CS2104, Lecture 4
8
Free and Bound Identifiers
local Z in
if X>Y then Z=1 else Z=0 end
end
Declaration Occurrence


and Y are free variable identifiers in this
statement (declared outside)
Z is a bound variable identifier in this
statement (declared inside)
X
7/17/2015
CS2104, Lecture 4
9
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.
7/17/2015
CS2104, Lecture 4
10
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.
7/17/2015
CS2104, Lecture 4
11
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.
7/17/2015
CS2104, Lecture 4
12
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.
7/17/2015
CS2104, Lecture 4
13
Free Identifiers and Free Occurrences
local 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!
7/17/2015
CS2104, Lecture 4
14
Procedures
proc {Max X Y ?Z}
% "?" is just a comment
if X>=Y then Z=X else Z=Y end
end
{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?
7/17/2015
CS2104, Lecture 4
15
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
7/17/2015
CS2104, Lecture 4
16
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.
7/17/2015
CS2104, Lecture 4
17
Procedures with external references
local 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}
end
end
 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.
7/17/2015
CS2104, Lecture 4
18
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.
7/17/2015
CS2104, Lecture 4
19
Lexical Scoping or Static Scoping
local X in
X=15
local X in
X=20
{Browse X}
end
{Browse X}
end
E2={Xx2}
E1 ={Xx1}
 There is just one identifier, X, but at different points
during the execution, it refers to different variables (x1
and x2).
7/17/2015
CS2104, Lecture 4
20
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.
7/17/2015
CS2104, Lecture 4
21
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.

7/17/2015
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.
CS2104, Lecture 4
22
Dynamic scoping versus static scoping
local 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}
end
end


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.
7/17/2015
CS2104, Lecture 4
23
Contextual Environment

When defining procedure, construct
contextual environment



maps all external references…
…to values at the time of definition
Procedure definition creates a closure


7/17/2015
pair of procedure and contextual environment
this closure is written to store
CS2104, Lecture 4
24
Example of Contextual Environment
local 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
end
end
7/17/2015
CS2104, Lecture 4

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
25
Environment Projection (last lecture)

Given: Environment E
E | {x1, …, xn}
is new environment E’ where only mappings
for {x1, …, xn} are retained from E
7/17/2015
CS2104, Lecture 4
26
Procedure Declaration

Semantic statement is
(proc {x y1 … yn} s end, E)



Formal parameters
External references
Contextual environment
y1, …, yn
z1, …, zm
CE = E | {z1, …, zm}
7/17/2015
CS2104, Lecture 4
27
Procedure Declaration

Semantic statement is
(proc {x y1 … yn} s end, E)

with E(x) = x
Create procedure value (closure or lexically
scoped closure)
(proc {$ y1 … yn} s end,
E | {z1, …, zm})
in the store and bind it to x
7/17/2015
CS2104, Lecture 4
28
Procedure Call

Values for



external references
actual parameters (actual arguments)
must be available to called procedure (“callee”)
As usual: construct new environment


7/17/2015
start from contextual environment for external
references
adjoin actual parameters
CS2104, Lecture 4
29
Procedure Call

Semantic statement is
({x y1 … yn}, E)
where


E(x) is to be called

y1, …, yn are actual parameters (arguments)

E(y1), …, E(yn) are actual entities (values)
Activation condition

7/17/2015
E(x) is determined
CS2104, Lecture 4
30
Procedure Call

Semantic statement is
({x y1 … yn}, E)

If the activation condition is false, then


If E(x) is not a procedure value, then


suspend the execution
raise an error
If E(x) is a procedure value, but with different
number of arguments (≠ n), then

7/17/2015
raise an error
CS2104, Lecture 4
31
Procedure Call

If semantic statement is
({x y1 … yn}, E)
with
E(x) = (proc {$ w1…wn} s end, CE)

then push
(s, CE + {w1E(y1), …, wnE(yn)})
7/17/2015
CS2104, Lecture 4
32
Executing a Procedure Call

If the activation condition “E(x) is determined” is true
 if E(x) matches ({x y1 … yn}, E)
(proc {$ w1…wn}
s end, CE)
+

(s, CE + {w1E(y1),
…, wnE(yn)})
ST
7/17/2015
+

ST
CS2104, Lecture 4
33
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
7/17/2015
CS2104, Lecture 4
34
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
7/17/2015
CS2104, Lecture 4
35
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
7/17/2015
CS2104, Lecture 4
36
Simple Example
([(local P Y Z in
Z=1
proc {P X} Y=X end
{P Z}
end, )],
)

Initial execution state
7/17/2015
CS2104, Lecture 4
37
Simple Example
([(local P Y Z in
Z=1
proc {P X} Y=X end
{P Z}
end, )],
)

Statement
7/17/2015
CS2104, Lecture 4
38
Simple Example
([(local P Y Z in
Z=1
proc {P X} Y=X end
{P Z}
end, )],
)

Empty environment
7/17/2015
CS2104, Lecture 4
39
Simple Example
([(local P Y Z in
Z=1
proc {P X} Y=X end
{P Z}
end, )],
)

Semantic statement
7/17/2015
CS2104, Lecture 4
40
Simple Example
([(local P Y Z in
Z=1
proc {P X} Y=X end
{P Z}
end, )],
)

Semantic stack
7/17/2015
CS2104, Lecture 4
41
Simple Example
([(local P Y Z in
Z=1
proc {P X} Y=X end
{P Z}
end, )],
)

Empty store
7/17/2015
CS2104, Lecture 4
42
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
7/17/2015
CS2104, Lecture 4
43
Simple Example
([(Z=1
proc {P X} Y=X end
{P Z},
{Pp, Yy, Zz})],
{p, y, z})
7/17/2015
CS2104, Lecture 4
44
Simple Example
([(Z=1
proc {P X} Y=X end
{P Z},
{Pp, Yy, Zz})],
{p, y, z})

Split sequential composition
7/17/2015
CS2104, Lecture 4
45
Simple Example
([(Z=1,
{Pp, Yy, Zz}),
(proc {P X} Y=X end
{P Z},
{Pp, Yy, Zz})],
{p, y, z})

Split sequential composition
7/17/2015
CS2104, Lecture 4
46
Simple Example
([(proc {P X} Y=X end
{P Z},
{Pp, Yy, Zz})],
{p, y, z=1})

Variable-value assignment
7/17/2015
CS2104, Lecture 4
47
Simple Example
([(proc {P X} Y=X end, {Pp, Yy, Zz}),
({P Z},
{Pp, Yy, Zz})],
{p, y, z=1})

Split sequential composition
7/17/2015
CS2104, Lecture 4
48
Simple Example
([(proc {P X} Y=X end, {Pp, Yy, Zz}),
({P Z},
{Pp, Yy, Zz})],
{p, y, z=1})

Procedure definition




external reference
formal argument
Y
X
Contextual environment {Yy}
Write procedure value to store
7/17/2015
CS2104, Lecture 4
49
Simple Example
([({P Z},
{Pp, Yy, Zz})],
{ p = (proc {$ X} Y=X end, {Yy}),
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, {Yy})
Environment


7/17/2015
start from
adjoin
{Y  y}
{X  z}
CS2104, Lecture 4
50
Simple Example
([(Y=X,
{Yy, Xz})],
{ p = (proc {$ X} Y=X end, {Yy}),
y, z=1})

Variable-variable assignment


7/17/2015
Variable for Y is
Variable for X is
y
z
CS2104, Lecture 4
51
Simple Example
([],
{ p = (proc {$ X} Y=X end, {Yy}),
y=1, z=1})

Voila!

The semantic stack is in the run-time state
terminated, since the stack is empty
7/17/2015
CS2104, Lecture 4
52
Discussion



Procedures take the values upon definition
Application automatically restores them
Not possible in Java, C, C++





7/17/2015
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
CS2104, Lecture 4
53
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
7/17/2015
CS2104, Lecture 4
54
Properties of the
Abstract Machine
7/17/2015
CS2104, Lecture 4
55
What Can We Use the Abstract Machine
for?

Proving properties
Understanding runtime
Understanding memory requirements

Abstract Machine is a model for computation



7/17/2015
implementations will refine model
CS2104, Lecture 4
56
Exploiting the Abstract Machine

We can define runtime of a statement s


We can understand how much memory
execution requires



the number of execution steps to execute s
semantic statements on the semantic stack
number of nodes in the store
What is really in the store?
7/17/2015
CS2104, Lecture 4
57
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
7/17/2015
CS2104, Lecture 4
58
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

7/17/2015
happens from time to time
CS2104, Lecture 4
59
Last Call Optimization
7/17/2015
CS2104, Lecture 4
60
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
7/17/2015
CS2104, Lecture 4
61
7/17/2015
CS2104, Lecture 4
62
Recursion at Work
([(local P in
P = proc {$} {P} end
{P}
end,

)],
)
Initial state
7/17/2015
CS2104, Lecture 4
63
Recursion at Work
([(P = proc {$} {P} end
{P}, {Pp})],
{p})

After execution of local
7/17/2015
CS2104, Lecture 4
64
Recursion at Work
([(P = proc {$} {P} end, {Pp}),
({P},
{Pp})],
{p})

After execution of sequential composition
7/17/2015
CS2104, Lecture 4
65
Recursion at Work
([({P}, {Pp})],
{p=(proc {$} {P} end,

{Pp})})
After execution of procedure definition


7/17/2015
external reference of body of P: P
contextual environment:
{Pp}
CS2104, Lecture 4
66
Recursion at Work
([({P}, {Pp})],
{p=(proc {$} {P} end,

After execution of procedure definition



{Pp})})
external reference of body of P: P
contextual environment:
{Pp}
Environment creates self reference
7/17/2015
CS2104, Lecture 4
67
Recursion at Work
([({P}, {Pp})],
{p=(proc {$} {P} end,



{Pp})})
Will continue forever
Stack will never grow!
Runs in constant space

7/17/2015
called iterative computation
CS2104, Lecture 4
68
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
7/17/2015
CS2104, Lecture 4
69
Some Steps…
([({Q}, {Qq})],
{q=(proc {$} {Q} {Q}

end,
{Qq})})
After execution of

local

sequential composition
procedure definition

7/17/2015
CS2104, Lecture 4
70
Procedure Call (1)
([({Q}, {Qq}),
({Q}, {Qq})],
{q=(proc {$} {Q} {Q}

end,
{Qq})})
After execution of procedure call


7/17/2015
no arguments
new environment is the same
contextual environment + argument environment
{Qq}
{}
CS2104, Lecture 4
71
Procedure Call (2)
([({Q}, {Qq}),
({Q}, {Qq}),
({Q}, {Qq})],
{q=(proc {$} {Q} {Q} end, {Qq})})

Stack grows with each step!
7/17/2015
CS2104, Lecture 4
72
Recursion: Summary

Iterative computations run in constant space

This concept is also called last call optimization

7/17/2015
no space needed for last call in procedure body
CS2104, Lecture 4
73
Two Functions…
M
N+M = 
1  ( N  1)  M
if N  0
if N  0
fun {SADD N M}
%% returns N+M for positive N
%% Slow ADDition
if N==0 then M else 1+{SADD N-1 M} end
end
fun {FADD N M}
%% returns N+M for positive N
%% Fast ADDition
if N==0 then M else {FADD N-1 M+1} end
end
7/17/2015
CS2104, Lecture 4
74
Questions

Which one is faster?

Which one uses less memory?

Why?

How?
7/17/2015
CS2104, Lecture 4
75
Answers…

Transform to kernel language

See how they compute

Answer the questions
7/17/2015
CS2104, Lecture 4
76
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
end
end
7/17/2015
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
end
end
7/17/2015
CS2104, Lecture 4
procedure call
after recursive
call
78
How Does SADD Compute?
local X Y Z in
X=4 Y=3
proc {SADD …} … end
{SADD X Y Z}
end
7/17/2015
CS2104, Lecture 4
79
Sketch for SADD
([({SADD
X Y Z},
([({SADD N1
(NM = 1 +
([({SADD N1
(NM = 1 +
(NM = 1 +
7/17/2015
…)], …)
M NM1},
NM1,
…),
…)], …)


M NM1},…),
NM1,
NM1,
…)
…)], …)
CS2104, Lecture 4
 …
80
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
end
end
7/17/2015
CS2104, Lecture 4
81
Procedure: FADD
recursive call is
last call
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
end
end
7/17/2015
CS2104, Lecture 4
82
Sketch for FADD
([({FADD X Y Z}, …)], …)

([({FADD
N1 M1 NM},
…)], …)

([({FADD
N1 M1 NM},
…)], …)

([({FADD N1 M1 NM}, …)], …)

7/17/2015
CS2104, Lecture 4
…
83
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)
7/17/2015
CS2104, Lecture 4
84
Summary so far: Most Important Concepts

Single-assignment variables


Abstract machine





partial values
a tool for understanding computations
a model of computation
based on environments
supports last call optimization
Procedures with contextual environment
7/17/2015
CS2104, Lecture 4
85
Abstract Machine

General approach to explain how a
programming language computes


model for computation
Can serve as base for implementation



7/17/2015
pioneered by Prolog
many other languages
recent: JVM (Java)
CLR (C#, …)
CS2104, Lecture 4
D.H.D. Warren, 1980’s
including Oz
SUN
Microsoft
86
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
7/17/2015
CS2104, Lecture 4
87
Summary

Computing with procedures





lexical scoping
closures
procedures as values
procedure call
Introduction of



7/17/2015
properties of the abstract machine
last call optimization
full syntax to kernel syntax
CS2104, Lecture 4
88
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]
7/17/2015
CS2104, Lecture 4
89
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
7/17/2015
CS2104, Lecture 4
90
Thank you for your attention!
Questions?
7/17/2015
CS2104, Lecture 4
91