SUMMARY ID1218 Lecture 122009-12-07 Christian Schulte cschulte@kth.se Software and Computer Systems...

SUMMARY

ID1218 Lecture 12 2009-12-07

Christian Schultecschulte@kth.se

Software and Computer SystemsSchool of Information and Communication

TechnologyKTH – Royal Institute of Technology

Stockholm, Sweden

Overview

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

see Lecture 10

L12 2009-12-07ID1218, Christian Schulte

Functional Programming

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

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

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

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

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

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}

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

Iterative Computations

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?

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

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!

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

Accumulators

Making Computations Iterative

L12 2009-12-07

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

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

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

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).

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)

Invariant for rev

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

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

as we go along

rev Final

rev([],Ys) ->

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

rev(Xr,[X|Ys]).

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

Higher-Order Programming

L12 2009-12-07

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 …

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

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])

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

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

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)

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

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) … ))

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

Concurrency

L12 2009-12-07

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

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)

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

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

Communication Patterns

L12 2009-12-07

Broadcast

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

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

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

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

Coordination

L12 2009-12-07

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

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

Slave: Blueprint

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

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?

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

Process State Reconsidered

L12 2009-12-07

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

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.

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")

Runtime Efficiency

L12 2009-12-07

Approach

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

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

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

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

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) }

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

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”

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

SUMMARY ID1218 Lecture 122009-12-07 Christian Schulte cschulte@kth.se Software and Computer Systems...

Documents

122009 Registros de capitais estrangeiros

RF Global Financial Crisis 122009 - cfainstitute.org

Badanie Blogosfery 122009

BORANG PENDAFTARAN - ewarga4.ukm.myewarga4.ukm.my/ewarga/pdf/122009/08-24.pdf · Pakar Psikiatri 9.30-10.30 pg Peranan JKM Dalam Perkhidmatan Kebajikan Pesakit Mental oleh Jabatan

Chapter 4 122009 phb - Pasco County, Florida

LOTRIČ Metrology d.o.o. · 2016. 9. 30. · API 6D:2008 - Annex H BMLION149 * Metode/ Specifikacije NIST Special Publication 960- 122009 BMI-IONIII * > 40 >150 >200 >250 >400 >800

Edital SEPPR 122009

Mesdan Uthm Presentation 122009

Of(Pl3.Q~ - VLS Finance · GURGAON-122009 Phone: 9810530637 0124-3298398 ... Provider, for extending the facility of electronic voting to the members of the Company from 9.00A.M

2309302 W670 E P 122009 - wagner-group.com · Una herramienta o llave puesta en una parte giratoria del equipo puede ... Manejo y uso cuidadoso de las herramientas ... impide el arranque

Manual 04012013.doc · Web viewardhendu.sen@gmail.com Arun Balakrishnan Council Member, The ICSI Flat no. TNC -122 Trinity Towers DLF, Phase-5 Gurgaon- 122009 Tel : (R) 0124-4018057

Tillämpad programmering · 2012. 11. 19. · Tillämpad programmering ID1218 INSTALL The simplest way to compile this package is: 1. `cd' to the directory containing the package's

-R.Colierkgsomani.com/wp-content/uploads/2018/02/Newsletter_… · · 2018-02-122009, it secured a 50 billion rupee ($1 billion) loan from State Bank of India (SBI.BO) to ... been

olympus kristmas 122009

Sweden CHRISTIAN SCHULTE, arXiv:1409.7628v3 [cs.PL] 7 Jun … · 229, Kista, 164 40, Sweden, RISE SICS, Box 1263, Kista, 164 40, Sweden, cschulte@kth.se. arXiv:1409.7628v3 [cs.PL]

MAN ATEX REV 122009 01PT MANUAL DE INSTRUÇÕES · reconhecida como defeituosa, em nossas oficinas. As peças ou acessórios alheios e que possuam uma marca própria não estão incluídos

23990647 Barclays Capital Global Outlook 122009

More Books At · PDF file · 2009-11-122009-11-12 · 5.6 Derivatives of Functions in Parametric Forms 179 ... co-domain and range have been introduced in Class XI ... :

Designa tion of Phone (With Line I Line II CITY PIN Code ...1 VIPUL LIMITED secretarial@vipulgroup.in PUNIT BERIWALA DIRT Vipul TechSquare, Golf Course Road, Sector-43, Gurgaon 122009

Biocon Limited Unpaid Dividend For The Financial year ... ANIL BEDI H1 C051 WESTEND HEIGHTS DLF CITY PHASE V GURGAON INDIA HARYANA GURGAON 122009 IN30014210182341 26 KULJEET KAUR SETHI