Mini erlang
This presentation is the property of its rightful owner.
Sponsored Links
1 / 49

Mini Erlang PowerPoint PPT Presentation


  • 69 Views
  • Uploaded on
  • Presentation posted in: General

Christian Schulte [email protected] Software and Computer Systems School of Information and Communication Technology KTH – Royal Institute of Technology Stockholm, Sweden. Mini Erlang. ID1218 Lecture 032009-11-02. Reminder & Overview. Roadmap: MiniErlang. What to compute with

Download Presentation

Mini Erlang

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript


Mini erlang

Christian Schulte

[email protected]

Software and Computer Systems

School of Information and Communication Technology

KTH – Royal Institute of Technology

Stockholm, Sweden

Mini Erlang

ID1218 Lecture 032009-11-02


Reminder overview

Reminder & Overview

ID1218, Christian Schulte


Roadmap minierlang

Roadmap: MiniErlang

  • What to compute with

    • MiniErlang expressions and programs

  • What are the results

    • MiniErlang Values

  • What are the instructions

    • for compound value construction and function call

  • How are functions called

    • parameters are passed by substitution

    • considers only matching clauses

    • clauses have patterns (we ignore guards)

  • ID1218, Christian Schulte


    Evaluating values

    Evaluating Values

    ID1218, Christian Schulte


    Minierlang values

    MiniErlang Values

    • A MiniErlang value is an integer or a list

      • other values are similar

  • In short notation

    V := int | [] | [V1|V2]

    • known as BNF notation: discussed later

    • so: values are referred to by V (possibly subscripted)

    • can be: any integer, the empty list, a cons consisting of two values V1 and V2

  • ID1218, Christian Schulte


    Minierlang expressions

    MiniErlang Expressions

    • A MiniErlang expression is a value, a variable, or a function call

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

      |X | F(E1,…, En)

      • expressions referred to by E

      • variables referred to by X

      • function names referred to by F

    ID1218, Christian Schulte


    Minierlang machine

    MiniErlang Machine

    • MiniErlang machine

      Es ; 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’

  • Initial configuration:

    • expression we want to evaluate on expression stack

  • Final configuration:

    • single value as result on value stack

  • ID1218, Christian Schulte


    Stacks

    Stacks

    • We write stacks as

      X1 …  Xn Xr

      • top of stack X1

      • n-th element Xn

      • more elementsXr

      • empty stack

  • Pushing X to stack Xr: X  Xr

  • Popping X from stack X  Xr:Xr

  • ID1218, Christian Schulte


    Minierlang execution idea

    MiniErlang Execution Idea

    • Simple case: an integer evaluates to itself

      • the result of an integer expression…

        …is an integer value

  • MiniErlang machine

    i  Er ; Vs→ Er ; i Vs

    • if the expression stack has the integer i as top of stack…

    • execution yields: the expression i is popped from the expression stack and pushed on to the value stack

    • same for empty list

  • ID1218, Christian Schulte


    Minierlang instruction idea

    MiniErlang Instruction Idea

    • How to evaluate a list expression [E1|E2]

      • first evaluate E1 , to a value V1, …

      • then evaluate E2 , to a value V2, …

      • then construct a new value [V1|V2]

  • Use an instruction that says: build a list

    • makes the assumption that values needed are on the value stack

    • execution will pop two values, push a new list value

    • when [E1|E2] is executed, E1 andE2 and the instruction CONS are pushed on the expression stack

  • ID1218, Christian Schulte


    Evaluating a list expression

    Evaluating a List Expression

    • Evaluate a list expression

      [E1|E2]Er ; Vs

      → E1E2CONSEr ; Vs

    • Execute a CONS instruction

      CONSEr ; V1V2Vs

      → Er ; [V2|V1]Vs

    ID1218, Christian Schulte


    Example

    Example

    • We want to evaluate the expression

      [1|[]](that is, just the list [1])

    • Start configuration of our machine

      [1|[]] ; 

      • expression stack:[1|[]]

      • empty value stack:

  • What should be the end configuration:

     ; [1|[]]

    • empty expression stack:

    • result on value stack:[1|[]]

  • ID1218, Christian Schulte


    Let s do it

    Let’s Do It!

    [1|[]] ; 

    → …

    [E1|E2]Er ; Vs

    → E1E2CONSEr ; Vs

    ID1218, Christian Schulte


    Let s do it1

    Let’s Do It!

    [1|[]] ; 

    → 1 []CONS ; 

    → …

    i Er ; Vs→ Er ; iVs

    ID1218, Christian Schulte


    Let s do it2

    Let’s Do It!

    [1|[]] ; 

    → 1 []CONS ; 

    → []CONS ;1

    →…

    i Er ; Vs→ Er ; iVs

    ID1218, Christian Schulte


    Let s do it3

    Let’s Do It!

    [1|[]] ; 

    → 1 []CONS ; 

    → []CONS ;1

    →CONS ;[]1

    →…

    CONSEr ; V1V2Vs

    → Er ; [V2|V1]Vs

    ID1218, Christian Schulte


    Let s do it4

    Let’s Do It!

    [1|[]] ; 

    → 1 []CONS ; 

    → []CONS ;1

    →CONS ;[]1

    →;[1|[]]

    ID1218, Christian Schulte


    Summary

    Summary

    • MiniErlang

      • values

      • expressions

  • MiniErlang machine

    • operates on expression and value stack

    • evaluates topmost expression on expr stack

    • executes topmost instruction on expr stack

  • Start state: single expr on expr stack

  • Final state: single value on value stack

  • ID1218, Christian Schulte


    Executing functions

    Executing Functions

    ID1218, Christian Schulte


    Roadmap

    Roadmap

    • How to evaluate arguments before executing function…

      • shuffle arguments on expression stack

      • have a call instruction

      • executing call instruction picks values from value stack

  • How to find the right clause

    • explain matching

  • How to pass parameters

    • replace variables by substitution

  • ID1218, Christian Schulte


    Evaluating function call

    Evaluating Function Call

    • Evaluate call expression

      F(E1, …, En)Er ; Vs

      → E1…EnCALL(F/n)Er ; Vs

    ID1218, Christian Schulte


    Minierlang patterns

    MiniErlang Patterns

    • Somehow: values + variables

    • Or, crisply:

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

    ID1218, Christian Schulte


    Pattern matching

    Pattern Matching

    • Pattern matching takes a pattern P and a value V and returns

      • true, iff the value matches the pattern

  • If V matches P, a substitution is returned

    • for each variable in the pattern P a matching value

  • Substitutions are applied to expressions

    • replacing variables by the respective values

  • Details come later, just the big picture now

  • ID1218, Christian Schulte


    Pattern matching examples

    Pattern Matching Examples

    • [X|Xr] matches [2|[1|[]]]

      • substitution { X 2, Xr [1|[]]}

  • [X|[X|Xr]] matches [2|[2|[]]]

    • substitution { X 2, Xr []}

  • [X|[X|Xr]] does not match [2|[1|[]]]

    • no substitution, of course

  • ID1218, Christian Schulte


    Substitution examples

    Substitution Examples

    • Application of

      • substitution { X 2, Xr [1|[]]} to

      • expression X+len(Xr) yields

      • yields2+len([1|[]])

  • We refer to

    • substitutions bys

    • application to expression E bys(E)

  • ID1218, Christian Schulte


    Reminder call expression

    Reminder: Call Expression

    • Evaluate call expression

      F(E1, …, En)Er ; Vs

      → E1…EnCALL(F/n)Er ; Vs

    ID1218, Christian Schulte


    Executing call

    Executing CALL

    CALL(F/n)Er ; V1…VnVs

    → s(E)Er ; Vs

    • F(P1, …, Pn) ->E is the first clause of F/n such that

      • the pattern [P1, …, Pn] matches…

        …the list value [Vn, …, V1]

      • with substitution s

    ID1218, Christian Schulte


    Example1

    Example

    • Assume we want to evaluate

      f([1|[]])

      where f/1 is defined by the single clause

      f([X|Xr]) -> [X|f(Xr)].

    ID1218, Christian Schulte


    Let s do it5

    Let’s Do It!

    f([1|[]]) ; 

    → [1|[]]CALL(f/1) ; 

    → 1[]CONSCALL(f/1) ; 

    → []CONSCALL(f/1) ;1

    → CONSCALL(f/1) ;[]1

    → CALL(f/1) ;[1|[]]

    → [1|f([])] ; 

    → …

    ID1218, Christian Schulte


    What do we ignore

    What Do We Ignore?

    • Runtime errors

      • what if no clause matches

  • Simplistic values

  • No un-nesting

  • No guards

    • simple: just check guards on values

  • No case and if expressions

    • rewrite to additional functions

  • ID1218, Christian Schulte


    An important fact

    An Important Fact…

    • The expressions on the expression stack must have an essential property…

      hmmm… Look to the example again!

    ID1218, Christian Schulte


    Last call optimization

    Last Call Optimization

    • MiniErlang has last call optimization (LCO) built in

      • remember what to do next on stack

      • do not remember where to return to

  • What effect for recursive programs?

  • ID1218, Christian Schulte


    Minierlang full picture

    MiniErlang Full Picture

    ID1218, Christian Schulte


    Making minierlang more realistic

    Making MiniErlang More Realistic

    • Substitution replaces variables in clause bodies by values

      • values will be deconstructed and reconstructed over and over again

  • Add single rule that optimizes values

    • an expression that is a value can be directly moved from the expression to the value stack

    • subsumes the rules for integers and the empty list

  • ID1218, Christian Schulte


    Minierlang values expressions instructions

    MiniErlang: Values, Expressions, Instructions

    • MiniErlang values

      V := int | [] | [V1|V2]

    • MiniErlang expressions

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

      | X | F(E1,…, En)

      • where X stands for a variable

  • MiniErlang instructions

    CONS, CALL

  • ID1218, Christian Schulte


    Minierlang expressions1

    MiniErlang: Expressions

    • Evaluate values

      V Er ; Vs→ Er ; VVs

      • provided V is a value

  • Evaluate list expression

    [E1|E2]Er ; Vs

    → E1E2CONSEr ; Vs

  • Evaluate function call

    F(E1, …, En)Er ; Vs

    → E1…EnCALL(F/n)Er ; Vs

  • ID1218, Christian Schulte


    Minierlang instructions

    MiniErlang: Instructions

    • CONS instruction

      CONSEr ; V1V2Vs

      → Er ; [V2|V1]Vs

    • CALL instruction

      CALL(F/n)Er ; V1…VnVs

      → s(E)Er ; Vs

      • F(P1, …, Pn) ->E first clause of F/n such that

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

    ID1218, Christian Schulte


    Minierlang pattern matching

    MiniErlang Pattern Matching

    • Patterns

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

    • match(P,V)

      s:=try(P,V)

      iferrorsorXV1,XV2 s withV1≠V2 thenno elses

      where

      try(i,i) = 

      try([],[]) = 

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

      try(X,V) = {XV}

      otherwise= {error}

    ID1218, Christian Schulte


    Pattern matching1

    Pattern Matching

    • Example

      match([A,A|[B|B]],[1,1,[]])

    • Uniform list notation

      match([A|[A|[B|B]]],[1|[1|[[]|[]]]])

    • Evaluate try

      try([A|[A|[B|B]]],[1|[1|[[]|[]]]])

    ID1218, Christian Schulte


    Evaluating try

    Evaluating try

    try([A|[A|[B|B]]],[1|[1|[[]|[]]]]) =

    try(A,1)  try([A|[B|B]],[1|[[]|[]]]) =

    {A1}  try(A,1)  try([B|B],[[]|[]]) =

    {A1}  {A1}  try(B,[])  try(B,[]) =

    {A1}  {B[]}  {B[]} =

    {A1, B[]}

    • Matches with substitution: {A1, B[]}

    ID1218, Christian Schulte


    Pattern matching2

    Pattern Matching

    • Example

      match([A,A|[B|B]],[1,2,[]])

    • Uniform list notation

      match([A|[A|[B|B]]],[1|[2|[[]|[]]]])

    • Evaluate try

      try([A|[A|[B|B]]],[1|[2|[[]|[]]]])

    ID1218, Christian Schulte


    Evaluating try1

    Evaluating try

    try([A|[A|[B|B]]],[1|[2|[[]|[]]]]) =

    try(A,1)  try([A|[B|B]],[2|[[]|[]]]) =

    {A1}  try(A,2)  try([B|B],[[]|[]]) =

    {A1}  {A2}  try(B,[])  try(B,[]) =

    {A1, A2}  {B[]}  {B[]} =

    {A1, A2, B[]}

    • Does not match!

    ID1218, Christian Schulte


    Substitution

    Substitution

    • Defined over structure of expressions

      s(i) = i

      s([]) = []

      s([E1|E2]) = [s(E1)|s(E2)]

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

      s(X)= ifXV  s thenVelse X

    ID1218, Christian Schulte


    Matching and substitutions

    Matching and Substitutions

    • If P matches V with substitution s

      s=match(P,V)

      then

      s(P)=V

    ID1218, Christian Schulte


    Substitution1

    Substitution

    • Assume s= {A1, B[]}

    • s([A|[A|[B|B]]]) =

      [s(A)|s([A|[B|B]])] =

      [1|[s(A)|s([B|B])]] =

      [1|[1|[s(B)|s(B)]]] =

      [1|[1|[[]|[]]]]

    ID1218, Christian Schulte


    Extending minierlang

    Extending MiniErlang

    • Built-in expressions, for example…

      • evaluate addition

        E1+E2Er ; Vs → E1E2ADDEr ; Vs

      • execute ADD instruction

        ADDEr ; V1V2Vs → Er ; V2+V1Vs

  • Comma operator

    • sequence of expressions

    • replace substitution by environment

    • lookup value for variable from environment

  • ID1218, Christian Schulte


    What did we actually do

    What Did We Actually Do?

    • Blueprint of MiniErlang implementation

      • operational semantics

      • capable of explaining how calls are handelled

      • stack machine

  • A real implementation

    • would statically replace (compilation) call and list construction to the respective instructions

    • would replace substitution by environments (registers)

    • …of a stack machine is the JVM!

  • ID1218, Christian Schulte


    What can we answer

    What Can We Answer

    • Faithful model for runtime

      • measure: number of function calls

      • all remaining operations are constant wrt function calls

  • Faithful model for memory

    • MiniErlang does not use heap memory: value stack

    • stack space: number of entries on either stack

    • space: size of entries on either stack

  • ID1218, Christian Schulte


    Homework

    Homework

    • Hand execute app/2 in MiniErlang!

    • Try all examples

    ID1218, Christian Schulte


  • Login