SUMMARY ID1218 Lecture 122009-12-07 Christian Schulte [email protected] Software and Computer Systems School of Information and Communication Technology.

SUMMARY

ID1218 Lecture 12 2009-12-07

Christian [email protected]

Software and Computer SystemsSchool of Information and Communication

TechnologyKTH – Royal Institute of Technology

Stockholm, Sweden

mailto:[email protected]

Overview

Only functional programming summary C++ summary and example questions,

see Lecture 10

L12 2009-12-07ID1218, Christian Schulte

2

Functional Programming


3

Evaluate functions returning results executed by MiniErlang machine

Techniques recursion with last-call-optimization pattern matching list processing higher-order programming accumulators

MiniErlang Machine

L12 2009-12-07

4

ID1218, Christian Schulte

MiniErlang: Values, Expressions, Instructions

MiniErlang valuesV := int | [] | [ V1 | V2 ]

MiniErlang expressions E := int | [] | [ E1 | E2 ]

| X | F(E1,…, En) where X stands for a variable

MiniErlang instructionsCONS, CALL


5

MiniErlang Machine

MiniErlang machineEs ; Vs → Es’ ; Vs’

transforms a pair (separated by ;) of expression stack Es and value stack Vs

into a new pair of expression stack Es’ and value stack Vs’

according to topmost element of Es Initial configuration:

expression we want to evaluate on expression stack Final configuration:

single value as result on value stack


6

MiniErlang: Expressions

Evaluate valuesV Er ; Vs → Er ; V Vs

provided V is a value Evaluate list expression

[E1|E2]Er ; Vs

→ E1E2CONSEr ; Vs Evaluate function call

F(E1, …, En)Er ; Vs

→ E1…EnCALL(F/n)Er ; VsL12 2009-12-07ID1218, Christian Schulte

7

MiniErlang: Instructions

CONS instructionCONSEr ; V1V2Vs

→ Er ; [V2|V1]Vs CALL instruction

CALL(F/n)Er ; V1…VnVs

→ s(E)Er ; Vs F(P1, …, Pn) -> E first clause of F/n such that

[P1, …, Pn] matches [Vn, …,V1] with substitution s


8

MiniErlang Pattern Matching

PatternsP := int | [] | [ P1 | P2 ] | X

match(P,V)s:=try(P,V)if errors or XV1, XV2 s withV1≠V2 then no else s

wheretry(i,i) = try([],[]) = try([P1|P2],[V1|V2])= try(P1,V1)try(P2,V2)

try(X,V) = {XV}otherwise = {error}


9

Substitution

Defined over structure of expressionss(i) = is([]) = []s([E1|E2]) = [s(E1)|s(E2)]

s(F(E1, …, En)) = F(s(E1), …, s(En))

s(X) = if XV s then V else X


10

Iterative Computations


11

A Better Length?


l([]) -> 0;l([_|Xr]) -> 1+l(Xr).

l([],N) -> N;l([_|Xr],N) -> l(Xr,N+1).

Two different functions: l/1 and l/2 Which one is better?

12

Running l/1

l([1,2,3]) ; → [1,2,3]CALL(l/1) ; → CALL(l/1) ; [1,2,3]→ 1+l([2,3]) ; → 1l([2,3])ADD ; → l([2,3])ADD ; 1→ [2,3]CALL(l/1)ADD ; 1→ CALL(l/1)ADD ; [2,3]1→ 1+l([3])ADD ; 1→ 1l([3])ADDADD ; 1→ l([3])ADDADD ; 11→ …

requires stack space in the length of list


13

Running l/2

l([1,2,3],0) ; → [1,2,3]0 CALL(l/2) ; → 0 CALL(l/2) ; [1,2,3]→ CALL(l/2) ; 0[1,2,3]→ l([2,3],0+1) ; → [2,3]0+1 CALL(l/2) ; → 0+1 CALL(l/2) ; [2,3]→ 01ADDCALL(l/2) ; [2,3]→ 1ADDCALL(l/2) ; 0[2,3]→ ADDCALL(l/2) ; 10[2,3]→ CALL(l/2) ; 1[2,3]→ l([3],1+1) ; → …

requires constant stack space!


14


Iterative Computations

Iterative computations run with constant stack space

Make use of last optimization call correspond to loops essentially

Tail recursive functions computed by iterative computations

15

Accumulators

Making Computations Iterative

L12 2009-12-07

16



Recursive Function

pow(_,0) -> 1;pow(X,N) -> X*pow(X,N-1).

Is not tail-recursive not an iterative function uses stack space in order of N

17


Using Accumulators

Accumulator stores intermediate result

Finding an accumulator amounts to finding an invariant

recursion maintains invariant invariant must hold initially result must be obtainable from invariant

18


State Invariant for pow/2

The invariant isXN = pow(X,N-i) * Xi

where i is the current iteration

Capture invariant with accumulator for Xi

initially (i=0) 1=X0

finally (i=N) XN

19


The pow/3 Function

pow(_,0,A) -> A;pow(X,N,A) -> pow(X,N-1,X*A).

pow(X,N) -> pow(X,N,1).

20


Naïve Reverse Function

rev([]) -> [];rev([X|Xr]) -> app(rev(Xr),[X]).

Some abbreviations r(Xs) for rev(Xs) Xs ++ Ys for app(Xs,Ys)

21


Invariant for rev

Now it is easy to see thatrev([x1, …, xn])

=rev([xi+1, …, xn]) ++ [xi, …, x1]

as we go along

22


rev Final

rev([],Ys) ->

Ys;

rev([X|Xr],Ys) ->

rev(Xr,[X|Ys]).

Is tail recursive now Cost: n+1 calls for list with n elements

23

Higher-Order Programming

L12 2009-12-07

24



Generic Procedures

Sorting a list in increasing or decreasing order by number or phone book order (maybe even a

Swedish phone book!) sorting algorithm + order

Mapping a list of numbers to list of square numbers to list of inverted numbers to list of square roots …

25


Map

map(_,[]) -> [];map(F,[X|Xr]) -> [F(X)|map(F,Xr)].

msq(Xs) -> map(fun (X) -> X*X end, Xs).

Use map/2 for any mapping function! Syntax of fun like case

26


Using Map

Mapping to square numbersmap(fun (X) -> X*X end,[1,2,3])

Mapping to negative numbersmap(fun (X) -> -X end,[1,2,3])

27


Other Examples

filter(F,Xs)returns all elements of Xs for which F returns true

any(F,Xs)tests whether Xs has an element for which F returns true

all(F,Xs)tests whether F returns true for all elements of Xs

28


Folding Lists

Consider computing the sum of list elements

…or the product …or all elements appended to a list …or the maximum …

What do they have in common?

Consider example: sl

29


Left-Folding

Two values define “folding” initial value 0 for sl binary function + for sl

Left-folding foldl(F,[x1 , …, xn],S)

F(… F(F(S,x1),x2) …,xn) or

(…((S F x1) F x2) … F xn)

30


foldl

foldl(_,[],S) -> S;foldl(F,[X|Xr],S) -> foldl(F,Xr,F(S,X)).

31


32

Right-Folding

Two values define “folding” initial value binary function

Right-folding foldr(F,[x1 … xn],S)

F(x1,F(x2, … F(xn,S)…))

orx1F(x2 F( … (xn F S) … ))


33

foldr

foldr(_,[],S) -> S;foldr(F,[X|Xr],S) -> F(X,foldr(F,Xr,S)).

Concurrency

L12 2009-12-07

34


Erlang Concurrency Primitives Creating processes

spawn(F) for function value F spawn(M,F,As) for function F in module M

with argument list As Sending messages

PID ! message Receiving messages

receive … end with clauses Who am I?

self() returns the PID of the current process


35

Processes

Each process has a mailbox incoming messages are stored in order of

arrival sending puts message in mailbox

Processes are executed fairly if a process can receive a message or

compute……eventually, it will

It will pretty soon… simple priorities available (low)


36

Message Sending

Message sending P ! M is asynchronous the sender does not wait until message has been

processed continues execution immediately evaluates to M

When a process sends messages M1 and M2 to same PID, they arrive in order in mailbox

FIFO ordering When a process sends messages M1 and M2

to different processes, order of arrival is undefined


37

Message Receipt

Only receive inspects mailbox all messages are put into the mailbox

Messages are processed in order of arrival that is, receive processes mailbox in order

If the receive statement has a matching clause for the first message

remove message and execute clause always choose the first matching clause

Otherwise, continue with next message Unmatched messages are kept in original

orderL12 2009-12-07ID1218, Christian Schulte

38

Communication Patterns

L12 2009-12-07

39


Broadcast

foreach(_,[]) -> void;foreach(F,[X|Xr]) -> F(X),foreach(Xr).

broadcast(PIDs,M) -> foreach(fun(PID) -> PID ! M end,PIDs).


40

Broadcast With Ordered Replycollect(PIDs,M) -> map(fun (P) -> P ! {self(),M}, receive {P,Reply} -> Reply end end, PIDs). Collect a reply from all processes in

orderL12 2009-12-07ID1218, Christian Schulte

41

Low-latency Collect

collect(PIDs,M) -> foreach(fun (P) -> P ! M end, PIDs), map(fun (P) -> receive {P,R} -> R end end, PIDs). No order


42

Coordination

L12 2009-12-07

43



44

Protocols

Protocol: rules for sending and receiving messages

programming with processes Examples

broadcasting messages to group of processes choosing a process

Important properties of protocols safety liveness


45

Choosing a Process

Example: choosing the best lift, connection, … More general: seeking agreement

coordinate execution

General idea: Master

send message to all slaves containing reply PID select one slave: accept all other slaves: reject

Slaves answer by replying to master PID wait for decision from master

Master: Blueprint

decide(SPs) -> Rs=collect(SPs,propose), {SP,SPr}=choose(SPs,Rs), SP ! {self(),accept}, broadcast(SPr,reject}. Generic:

collecting and broadcasting Specific:

choose single process from processes based on replies Rs


46

Slave: Blueprint

slave() -> receive {M,propose} -> R=…, M ! {self(),R}, receive {M,accept} -> …; {M,reject} -> … end end


47


48

Avoiding Deadlock

Master can only proceed, after all slaves answered

will not process any more messages until then receiving messages in collect

Slave can only proceed, after master answered

will not process any more messages until then What happens if multiple masters for

same slaves?


49

Avoiding Deadlock

Force all masters to send in order: First A, then B, then C, … Guarantee: If A available, all others will be available difficult: what if dynamic addition and removal of

lists does not work with low-latency collect

low-latency: messages can arrive in any order high-latency: receipt imposes strict order

Use an adaptor access to slaves through one single master slaves send message to single master problem: potential bottleneck

Liveness Properties

Important property of concurrent programsliveness

An event/activity might fail to be live other activities consume all CPU power message box is flooded (denial of services) activities have deadlocked …

Difficult: all possible interactions with other processes must guarantee liveness

reasoning of all possible interactions


50

Process State Reconsidered

L12 2009-12-07

51



52

State and Concurrency

Difficult to guarantee that state is maintained consistently in a concurrent setting

Typically needed: atomic execution of several statements together

Processes guarantee atomic execution

Locking Processes

Idea that is used most often in languages which rely on state

Before state can be manipulated: lock must be acquired

for example, one lock per object If process has acquired lock: can perform

operations If process is done, lock is released


53

A Lockable Process

outside(F,InS) -> receive {acquire,PID} -> PID ! {ok,self()}, inside(F,InS,PID) end.inside(F,InS,PID) -> receive {release,PID} -> outside(F,InS) {PID,Msg} -> inside(F,F(Msg,InS)); end.


54

Safety Properties

Maintain state of processes in consistent fashion

do not violate invariants to not compute incorrect results

Guarantee safety by atomic execution exclusion of other processes ("mutual

exclusion")


55

Runtime Efficiency

L12 2009-12-07

56



57

Approach

Take MiniErlang program Take execution time for each expression Give equations for runtime of functions Solve equations Determine asymptotic complexity


58

Execution Times for Expressions

Give inductive definition based on function definition and structure of expressions

Function definition pattern matching and guards

Simple expression values and list construction

More involved expression function call recursive function call leads to recursive

equation often called: recurrence equation


59

Execution Time: T(E)

ValueT(V) = cvalue

List constructionT([E1|E2]) = ccons + T(E1) + T(E2)

Time T(E) needed for executing expression E

how MiniErlang machine executes E


60

Function Call

For a function F define a functionTF(n) for its runtime

and determine size of input for call to F input for a function


61

Function Call

T(F(E1, ..., Ek)) = ccall + T(E1) + ... + T(Ek)

+ TF(size(IF({1, ..., k})))

input arguments IF({1, ..., k}) input arguments for F

size size(IF({1, ..., k}))size of input for F

Function Definition

Assume function F defined by clausesH1 -> B1; …; Hk -> Bk.

TF(n) = cselect + max { T(B1), …, T(Bk) }


62


63

Example: app/2

app([],Ys)

-> Ys;

app([X|Xr],Ys)

-> [X|app(Xr,Ys)].

What do we want to compute

Tapp(n) Knowledge needed

input argument first argument size function length of list


64

Append: Recurrence Equation Analysis yields

Tapp(0) = c1

Tapp(n) = c2 + Tapp(n-1) Solution to recurrence is

Tapp(n) = c1 + c2 n Asymptotic complexity

Tapp(n) is of O(n) “linear complexity”


65

Recurrence Equations

Analysis in general yields a system T(n) defined in terms of

T(m1), …, T(mk)

for m1, …, mk < n T(0), T(1), … values for certain n

Possibilities solve recurrence equation (difficult in general) lookup asymptotic complexity for common case

L12 2009-12-07 ID1218, Christian Schulte 66

Common Recurrence Equations

T(n) Asymptotic Complexity

c + T(n–1) O(n)

c1 + c2n + T(n–1) O(n2)

c + T(n/2) O(log n)

c1 + c2n + T(n/2) O(n)

c + 2T(n/2) O(n)

c + 2T(n-1) O(2n)

c1 + c2n + T(n/2) O(n log n)

That’s It!

L12 2009-12-07

67


SUMMARY ID1218 Lecture 122009-12-07 Christian Schulte [email protected] Software and Computer Systems School of Information and Communication Technology.

Documents