Stephen A. Edwards - Columbia Universitysedwards/classes/2014/w4115-summer-cvn/final-review.pdfDeterministic Finite Automata Restricted form of NFAs: ˇ No state has a transition on

Review for the Final

Stephen A. Edwards

Columbia University

Fall 2010

Table of Contents I

The Final

Structure of a Compiler

Scanning

Languages and Regular Expressions

NFAs

Translating REs into NFAs

Building a DFA from an NFA: Subset Construction

Parsing

Resolving Ambiguity

Table of Contents IIRightmost and Reverse-Rightmost Derivations

Building the LR(0) Automaton

Building an SLR Parsing Table

Shift/Reduce Parsing

Name, Scope, and Bindings

Activation Records

Static Links for Nested Functions

Types

C’s Types

Layout of Records and Unions

Arrays

Name vs. Structural Equivalence

Table of Contents IIIControl Flow

Order of Evaluation

Structured Programming

Multi-Way Branching

Recursion vs. Iteration

Applicative vs. Normal-Order Evaluation

Nondeterminism

Code Generation

Intermediate Representations

Optimization and Basic Blocks

Separate Compilation and Linking

Shared Libraries and Dynamic Linking

Table of Contents IV

Logic Programming in Prolog

Prolog Execution

The Prolog Environment

Unification

The Searching Algorithm

Prolog as an Imperative Language

Table of Contents V

The Lambda Calculus

Lambda Expressions

Beta-reduction

Alpha-conversion

Reduction Order

Normal Form

The Y Combinator

Table of Contents VIParallel Programming in OpenMP

Processes vs. Threads

OpenMP

The Fork-Join Task Model

Parallel Regions

The For Construct

Critical Regions

Reduction

Barriers

The Final

70 minutes

4–5 problems

Closed book

One double-sided sheet of notes of your own devising

Comprehensive: Anything discussed in class is fair game, includingthings from before the midterm

Little, if any, programming

Details of O’Caml/C/C++/Java syntax not required

Broad knowledge of languages discussed

Compiling a Simple Program

int gcd(int a, int b){while (a != b) {if (a > b) a -= b;else b -= a;

}return a;

}

What the Compiler Seesint gcd(int a, int b){while (a != b) {if (a > b) a -= b;else b -= a;

}return a;

}

i n t sp g c d ( i n t sp a , sp in t sp b ) nl { nl sp sp w h i l e sp( a sp ! = sp b ) sp { nl sp sp sp sp if sp ( a sp > sp b ) sp a sp - = sp b; nl sp sp sp sp e l s e sp b sp - = spa ; nl sp sp } nl sp sp r e t u r n spa ; nl } nl

Text file is a sequence of characters

Lexical Analysis Gives Tokens


}return a;

}

int gcd ( int a , int b ) { while ( a

!= b ) { if ( a > b ) a -= b ; else

b -= a ; } return a ; }

A stream of tokens. Whitespace, comments removed.

Parsing Gives an Abstract Syntax Tree

func

int gcd args

arg

int a

arg

int b

seq

while

!=

a b

if

>

a b

-=

a b

-=

b a

return

a


}return a;

}

Semantic Analysis Resolves Symbols and Checks Types

Symbol Table

int a

int b

func

int gcd args

arg

int a

arg

int b

seq

while

!=

a b

if

>

a b

-=

a b

-=

b a

return

a

Translation into 3-Address Code

L0: sne $1, a, bseq $0, $1, 0btrue $0, L1 # while (a != b)sl $3, b, aseq $2, $3, 0btrue $2, L4 # if (a < b)sub a, a, b # a -= bjmp L5

L4: sub b, b, a # b -= aL5: jmp L0L1: ret a


}return a;

}

Idealized assembly language w/infinite registers

Generation of 80386 Assembly

gcd: pushl %ebp # Save BPmovl %esp,%ebpmovl 8(%ebp),%eax # Load a from stackmovl 12(%ebp),%edx # Load b from stack

.L8: cmpl %edx,%eaxje .L3 # while (a != b)jle .L5 # if (a < b)subl %edx,%eax # a -= bjmp .L8

.L5: subl %eax,%edx # b -= ajmp .L8

.L3: leave # Restore SP, BPret

Describing Tokens

Alphabet: A finite set of symbols

Examples: { 0, 1 }, { A, B, C, . . . , Z }, ASCII, Unicode

String: A finite sequence of symbols from an alphabet

Examples: ε (the empty string), Stephen, αβγ

Language: A set of strings over an alphabet

Examples: ; (the empty language), { 1, 11, 111, 1111 }, all Englishwords, strings that start with a letter followed by any sequence ofletters and digits

Operations on Languages

Let L = { ε, wo }, M = { man, men }

Concatenation: Strings from one followed by the other

LM = { man, men, woman, women }

Union: All strings from each language

L∪M = {ε, wo, man, men }

Kleene Closure: Zero or more concatenations

M∗ = {ε}∪M ∪MM ∪MMM · · · ={ε, man, men, manman, manmen, menman, menmen,manmanman, manmanmen, manmenman, . . . }

Regular Expressions over an Alphabet Σ

A standard way to express languages for tokens.

1. ε is a regular expression that denotes {ε}

2. If a ∈Σ, a is an RE that denotes {a}

3. If r and s denote languages L(r) and L(s),

Ï (r) | (s) denotes L(r)∪L(s)Ï (r)(s) denotes {tu : t ∈ L(r),u ∈ L(s)}Ï (r)∗ denotes ∪∞

i=0Li (L0 = {ε} and Li = LLi−1)

Nondeterministic Finite Automata

“All strings containing aneven number of 0’s and 1’s”

A B

C D

0

0

11

0

0

1 1

1. Set of states

S :

{A B C D

}2. Set of input symbols Σ : {0,1}3. Transition function σ : S×Σε → 2S

state ε 0 1A ; {B} {C}B ; {A} {D}C ; {D} {A}D ; {C} {B}

4. Start state s0 : A

5. Set of accepting states F :

{A

}

The Language induced by an NFA

An NFA accepts an input string x iff there is a path from the startstate to an accepting state that “spells out” x.

A B

C D

0

0

11

0

0

1 1

Show that the string “010010” is accepted.

A B D C D B A0 1 0 0 1 0


aa

Symbol

r1r2 r1 r2r1 Sequence

r1 | r2

r1

r2

ε

ε

ε

ε

Choice

(r)∗ rε ε

ε

ε

Kleene Closure


aa

Symbol

r1r2 r1 r2r1 Sequence

r1 | r2

r1

r2

ε

ε

ε

ε

Choice

(r)∗ rε ε

ε

ε

Kleene Closure


Example: Translate (a | b)∗abb into an NFA. Answer:

0 1

2 3

4 5

6 7 8 9 10ε

εa

εb

ε

ε

ε a b b

ε

ε

Show that the string “aabb” is accepted. Answer:

0 1 2 3 6 7 8 9 10ε ε a ε ε a b b

Simulating NFAs

Problem: you must follow the “right” arcs to show that a string isaccepted. How do you know which arc is right?

Solution: follow them all and sort it out later.

“Two-stack” NFA simulation algorithm:

1. Initial states: the ε-closure of the start state

2. For each character c,Ï New states: follow all transitions labeled cÏ Form the ε-closure of the current states

3. Accept if any final state is accepting

Simulating an NFA: ·aabb, Start

0 1

2 3

4 5

6 7 8 9 10ε

εa

εb

ε

ε

ε a b b

ε

ε

0 1

2 3

4 5

6 7 8 9 10ε

εa

εb

ε

ε

ε a b b

ε

ε

Simulating an NFA: a·abb

0 1

2 3

4 5

6 7 8 9 10ε

εa

εb

ε

ε

ε a b b

ε

ε

0 1

2 3

4 5

6 7 8 9 10ε

εa

εb

ε

ε

ε a b b

ε

ε

Simulating an NFA: aa·bb

0 1

2 3

4 5

6 7 8 9 10ε

εa

εb

ε

ε

ε a b b

ε

ε

0 1

2 3

4 5

6 7 8 9 10ε

εa

εb

ε

ε

ε a b b

ε

ε

Simulating an NFA: aab·b

0 1

2 3

4 5

6 7 8 9 10ε

εa

εb

ε

ε

ε a b b

ε

ε

0 1

2 3

4 5

6 7 8 9 10ε

εa

εb

ε

ε

ε a b b

ε

ε

Simulating an NFA: aabb·, Done

0 1

2 3

4 5

6 7 8 9 10ε

εa

εb

ε

ε

ε a b b

ε

ε

0 1

2 3

4 5

6 7 8 9 10ε

εa

εb

ε

ε

ε a b b

ε

ε

Deterministic Finite Automata

Restricted form of NFAs:

Ï No state has a transition on ε

Ï For each state s and symbol a, there is at most one edge labeleda leaving s.

Differs subtly from the definition used in COMS W3261 (Sipser,Introduction to the Theory of Computation)

Very easy to check acceptance: simulate by maintaining currentstate. Accept if you end up on an accepting state. Reject if you endon a non-accepting state or if there is no transition from the currentstate for the next symbol.


{type token = ELSE | ELSEIF

}

rule token =parse "else" { ELSE }

| "elseif" { ELSEIF }

e l s e i f


{ type token = IF | ID of string | NUM of string }

rule token =parse "if" { IF }

| [’a’-’z’] [’a’-’z’ ’0’-’9’]* as lit { ID(lit) }| [’0’-’9’]+ as num { NUM(num) }

NUM

ID IF

ID

0–9

i

a–hj–z

f

a–z0–9

a–eg–z0–9

0–9

a–z0–9

Building a DFA from an NFA

Subset construction algorithm

Simulate the NFA for all possible inputs and track the states thatappear.

Each unique state during simulation becomes a state in the DFA.

Subset construction for (a | b)∗abb

a

b

a

b

b

a

a

ba

b

Result of subset construction for (a | b)∗abb

a

b

ab

b

a

a

ba

b

Is this minimal?

Ambiguous Arithmetic

Ambiguity can be a problem in expressions. Consider parsing

3 - 4 * 2 + 5

with the grammar

e → e+e | e−e | e∗e | e /e | N

+

-

3 *

4 2

5

-

3 +

*

4 2

5

*

-

3 4

+

2 5

-

3 *

4 +

2 5

-

*

+

3 4

2

5

Operator Precedence

Defines how “sticky” an operator is.

1 * 2 + 3 * 4

* at higher precedence than +:

(1 * 2) + (3 * 4)

+

*

1 2

*

3 4

+ at higher precedence than *:

1 * (2 + 3) * 4

*

*

1 +

2 3

4

AssociativityWhether to evaluate left-to-right or right-to-left

Most operators are left-associative

1 - 2 - 3 - 4

-

-

-

1 2

3

4

-

1 -

2 -

3 4

((1−2)−3)−4 1− (2− (3−4))

left associative right associative

Fixing Ambiguous Grammars

A grammar specification:

expr :expr PLUS expr

| expr MINUS expr| expr TIMES expr| expr DIVIDE expr| NUMBER

Ambiguous: no precedence or associativity.

Ocamlyacc’s complaint: “16 shift/reduce conflicts.”

Assigning Precedence Levels

Split into multiple rules, one per level

expr : expr PLUS expr| expr MINUS expr| term

term : term TIMES term| term DIVIDE term| atom

atom : NUMBER

Still ambiguous: associativity not defined

Ocamlyacc’s complaint: “8 shift/reduce conflicts.”

Assigning Associativity

Make one side the next level of precedence

expr : expr PLUS term| expr MINUS term| term

term : term TIMES atom| term DIVIDE atom| atom

atom : NUMBER

This is left-associative.

No shift/reduce conflicts.

Rightmost Derivation of Id∗ Id+ Id

1 :e→ t +e2 :e→ t3 : t→Id ∗ t4 : t→Id

et + e

t + t

t + Id

Id ∗ t + Id

Id ∗ Id + Id

At each step, expand the rightmost nonterminal.

nonterminal

“handle”: The right side of a production

Fun and interesting fact: there is exactly one rightmost expansion ifthe grammar is unambigious.

Rightmost Derivation: What to Expand

1 :e→ t +e2 :e→ t3 : t→Id ∗ t4 : t→Id

et + et + t

t + Id

Id ∗ t + Id

Id ∗ Id + Id

Expand here ↑ Terminals only

e

t + e

t + t

t + Id

Id ∗ t + Id

Id ∗ Id + Id

Reverse Rightmost Derivation

1 :e→ t +e2 :e→ t3 : t→Id ∗ t4 : t→Id

et + et + t

t + Id

Id ∗ t + Id

Id ∗ Id + Id

viable prefixes terminals

Id ∗ Id + Id Id

tId ∗ t + Id ∗Id

tt + Id Id

tt + t

et + e

e

+e

Shift/Reduce Parsing Using an Oracle

1 :e→ t +e2 :e→ t3 : t→Id ∗ t4 : t→Id

et + et + t

t + Id

Id ∗ t + Id

Id ∗ Id + Id

stack input

Id ∗ Id + Id shiftId ∗ Id + Id shift

Id ∗ Id + Id shiftId ∗ Id + Id reduce 4

Id ∗ t + Id reduce 3t + Id shift

t + Id shiftt + Id reduce 4

t + t reduce 2t + e reduce 1

e accept

Handle Hunting

Right Sentential Form: any step in a rightmost derivation

Handle: in a sentential form, a RHS of a rule that, when rewritten,yields the previous step in a rightmost derivation.

The big question in shift/reduce parsing:

When is there a handle on the top of the stack?

Enumerate all the right-sentential forms and pattern-match againstthem? Usually infinite in number, but let’s try anyway.

The Handle-Identifying AutomatonMagical result, due to Knuth: An automaton suffices to locate ahandle in a right-sentential form.

Id∗ Id∗·· ·∗ Id∗ t · · ·Id∗ Id∗·· ·∗ Id · · ·t + t +·· ·+ t +e

t + t +·· ·+ t+ Id

t + t +·· ·+ t + Id∗ Id∗·· ·∗ Id∗ t

t + t +·· ·+ t

Id

t

Id∗ t

t +e

e

t

+t

e

IdId

∗Id

t

e

Building the Initial State of the LR(0) Automaton

1 :e→ t +e2 :e→ t3 : t→Id ∗ t4 : t→Id

e′ →·e

e →·t +ee →·tt →·Id∗ tt →·Id

Key idea: automata identify viable prefixes of right sentential forms.Each state is an equivalence class of possible places in productions.

At the beginning, any viable prefix must be at the beginning of astring expanded from e. We write this condition “e′ →·e”

There are two choices for what an e may expand to: t +e and t. Sowhen e′ →·e, e →·t +e and e →·t are also true, i.e., it must start witha string expanded from t.

Similarly, t must be either Id∗ t or Id, so t →·Id∗ t and t →·Id.

This reasoning is a closure operation like ε-closure in subsetconstruction.


1 :e→ t +e2 :e→ t3 : t→Id ∗ t4 : t→Id

e′ →·ee →·t +ee →·t

t →·Id∗ tt →·Id







1 :e→ t +e2 :e→ t3 : t→Id ∗ t4 : t→Id

e′ →·ee →·t +ee →·tt →·Id∗ tt →·Id







S0 :


S1 :t → Id ·∗tt → Id·

S7 : e′ → e·

S2 :e → t ·+ee → t·

e

Id

t

S3 :t → Id∗·t


S4 :

e → t +·e


∗

+

S5 : t → Id∗ t·t

Id

S6 : e → t +e·

t

Id e

“Just passed a prefix

ending in a string

derived from t”


that ended in an Id”

“Just passed a

string derived

from e”

The first state suggests a viableprefix can start as any stringderived from e, any string derivedfrom t, or Id.

The items for these three statescome from advancing the · acrosseach thing, then performing theclosure operation (vacuous here).

In S2, a + may be next. This givest +·e.

Closure adds 4 more items.

In S1, ∗ may be next, giving Id∗·t

and two others.


S0 :


S1 :t → Id ·∗tt → Id·

S7 : e′ → e·

S2 :e → t ·+ee → t·

e

Id

t

S3 :t → Id∗·t


S4 :

e → t +·e


∗

+

S5 : t → Id∗ t·t

Id

S6 : e → t +e·

t

Id e


ending in a string

derived from t”



“Just passed a

string derived

from e”The first state suggests a viableprefix can start as any stringderived from e, any string derivedfrom t, or Id.





and two others.


S0 :


S1 :t → Id ·∗tt → Id·

S7 : e′ → e·

S2 :e → t ·+ee → t·

e

Id

t

S3 :t → Id∗·t


S4 :

e → t +·e


∗

+

S5 : t → Id∗ t·t

Id

S6 : e → t +e·

t

Id e


ending in a string

derived from t”



“Just passed a

string derived






and two others.


S0 :


S1 :t → Id ·∗tt → Id·

S7 : e′ → e·

S2 :e → t ·+ee → t·

e

Id

t

S3 :t → Id∗·tt →·Id∗ tt →·Id

S4 :

e → t +·ee →·t +ee →·tt →·Id∗ tt →·Id

∗

+

S5 : t → Id∗ t·t

Id

S6 : e → t +e·

t

Id e


ending in a string

derived from t”



“Just passed a

string derived



In S2, a + may be next. This givest +·e. Closure adds 4 more items.

In S1, ∗ may be next, giving Id∗·tand two others.


S0 :


S1 :t → Id ·∗tt → Id·

S7 : e′ → e·

S2 :e → t ·+ee → t·

e

Id

t

S3 :t → Id∗·tt →·Id∗ tt →·Id

S4 :

e → t +·ee →·t +ee →·tt →·Id∗ tt →·Id

∗

+

S5 : t → Id∗ t·t

Id

S6 : e → t +e·

t

Id e


ending in a string

derived from t”



“Just passed a

string derived






and two others.

Converting the LR(0) Automaton to an SLR Parsing Table

S0

S1: t → Id·

S2: e → t·

S3

S4

S5: t → Id∗ t·

S6: e → t +e·

S7: e′ → e·

t

Id

e

∗

+

Id

t

t

e

Id

1 :e→ t +e2 :e→ t3 : t→Id ∗ t4 : t→Id

State Action Goto

Id + ∗ $ e t

0 s1 7 2

1 r4 s3 r42 s4 r23 s1 54 s1 6 25 r3 r36 r17 X

From S0, shift an Id and go to S1; orcross a t and go to S2; or cross an eand go to S7.


S0

S1: t → Id·

S2: e → t·

S3

S4

S5: t → Id∗ t·

S6: e → t +e·

S7: e′ → e·

t

Id

e

∗

+

Id

t

t

e

Id

1 :e→ t +e2 :e→ t3 : t→Id ∗ t4 : t→Id

State Action Goto

Id + ∗ $ e t

0 s1 7 21 r4 s3 r4

2 s4 r23 s1 54 s1 6 25 r3 r36 r17 X

From S1, shift a ∗ and go to S3; or, ifthe next input could follow a t,reduce by rule 4. According to rule 1,+ could follow t; from rule 2, $ could.


S0

S1: t → Id·

S2: e → t·

S3

S4

S5: t → Id∗ t·

S6: e → t +e·

S7: e′ → e·

t

Id

e

∗

+

Id

t

t

e

Id

1 :e→ t +e2 :e→ t3 : t→Id ∗ t4 : t→Id

State Action Goto

Id + ∗ $ e t

0 s1 7 21 r4 s3 r42 s4 r2

3 s1 54 s1 6 25 r3 r36 r17 X

From S2, shift a + and go to S4; or, ifthe next input could follow an e (onlythe end-of-input $), reduce by rule 2.


S0

S1: t → Id·

S2: e → t·

S3

S4

S5: t → Id∗ t·

S6: e → t +e·

S7: e′ → e·

t

Id

e

∗

+

Id

t

t

e

Id

1 :e→ t +e2 :e→ t3 : t→Id ∗ t4 : t→Id

State Action Goto

Id + ∗ $ e t

0 s1 7 21 r4 s3 r42 s4 r23 s1 5

4 s1 6 25 r3 r36 r17 X

From S3, shift an Id and go to S1; orcross a t and go to S5.


S0

S1: t → Id·

S2: e → t·

S3

S4

S5: t → Id∗ t·

S6: e → t +e·

S7: e′ → e·

t

Id

e

∗

+

Id

t

t

e

Id

1 :e→ t +e2 :e→ t3 : t→Id ∗ t4 : t→Id

State Action Goto

Id + ∗ $ e t

0 s1 7 21 r4 s3 r42 s4 r23 s1 54 s1 6 2

5 r3 r36 r17 X

From S4, shift an Id and go to S1; orcross an e or a t.


S0

S1: t → Id·

S2: e → t·

S3

S4

S5: t → Id∗ t·

S6: e → t +e·

S7: e′ → e·

t

Id

e

∗

+

Id

t

t

e

Id

1 :e→ t +e2 :e→ t3 : t→Id ∗ t4 : t→Id

State Action Goto

Id + ∗ $ e t

0 s1 7 21 r4 s3 r42 s4 r23 s1 54 s1 6 25 r3 r3

6 r17 X

From S5, reduce using rule 3 if thenext symbol could follow a t (again,+ and $).


S0

S1: t → Id·

S2: e → t·

S3

S4

S5: t → Id∗ t·

S6: e → t +e·

S7: e′ → e·

t

Id

e

∗

+

Id

t

t

e

Id

1 :e→ t +e2 :e→ t3 : t→Id ∗ t4 : t→Id

State Action Goto

Id + ∗ $ e t

0 s1 7 21 r4 s3 r42 s4 r23 s1 54 s1 6 25 r3 r36 r1

7 X

From S6, reduce using rule 1 if thenext symbol could follow an e ($only).


S0

S1: t → Id·

S2: e → t·

S3

S4

S5: t → Id∗ t·

S6: e → t +e·

S7: e′ → e·

t

Id

e

∗

+

Id

t

t

e

Id

1 :e→ t +e2 :e→ t3 : t→Id ∗ t4 : t→Id

State Action Goto

Id + ∗ $ e t

0 s1 7 21 r4 s3 r42 s4 r23 s1 54 s1 6 25 r3 r36 r17 X

If, in S7, we just crossed an e, acceptif we are at the end of the input.

Shift/Reduce Parsing with an SLR Table

1 :e→ t +e2 :e→ t3 : t→Id ∗ t4 : t→Id

State Action Goto

Id + ∗ $ e t

0 s1 7 21 r4 s3 r42 s4 r23 s1 54 s1 6 25 r3 r36 r17 X

Stack Input Action

0 Id∗ Id+ Id$ Shift, goto 1

Look at the state on top of the stackand the next input token.

Find the action (shift, reduce, or error)in the table.

In this case, shift the token onto thestack and mark it with state 1.

0Id1 ∗Id+ Id$ Shift, goto 3

0Id1

∗3 Id+ Id$ Shift, goto 1

0Id1

∗3

Id1 +Id$ Reduce 4

0Id1

∗3

t5 +Id$

Reduce 3

0t2 +Id$ Shift, goto 4

0t2

+4 Id$ Shift, goto 1

0t2

+4

Id1 $ Reduce 4

0t2

+4

t2 $ Reduce 2

0t2

+4

e6 $ Reduce 1

0e7 $ Accept


1 :e→ t +e2 :e→ t3 : t→Id ∗ t4 : t→Id

State Action Goto

Id + ∗ $ e t

0 s1 7 21 r4 s3 r42 s4 r23 s1 54 s1 6 25 r3 r36 r17 X

Stack Input Action



Here, the state is 1, the next symbol is∗, so shift and mark it with state 3.

0Id1


0Id1

∗3

Id1 +Id$ Reduce 4

0Id1

∗3

t5 +Id$

Reduce 3


0t2


0t2

+4

Id1 $ Reduce 4

0t2

+4

t2 $ Reduce 2

0t2

+4

e6 $ Reduce 1

0e7 $ Accept


1 :e→ t +e2 :e→ t3 : t→Id ∗ t4 : t→Id

State Action Goto

Id + ∗ $ e t

0 s1 7 21 r4 s3 r42 s4 r23 s1 54 s1 6 25 r3 r36 r17 X

Stack Input Action



0Id1


0Id1

∗3

Id1 +Id$ Reduce 4

Here, the state is 1, the next symbol is+. The table says reduce using rule 4.

0Id1

∗3

t5 +Id$

Reduce 3


0t2


0t2

+4

Id1 $ Reduce 4

0t2

+4

t2 $ Reduce 2

0t2

+4

e6 $ Reduce 1

0e7 $ Accept


1 :e→ t +e2 :e→ t3 : t→Id ∗ t4 : t→Id

State Action Goto

Id + ∗ $ e t

0 s1 7 21 r4 s3 r42 s4 r23 s1 54 s1 6 25 r3 r36 r17 X

Stack Input Action



0Id1


0Id1

∗3

Id1 +Id$ Reduce 4

0Id1

∗3

t5

+Id$

Reduce 3

Remove the RHS of the rule (here, justId), observe the state on the top of thestack, and consult the “goto” portionof the table.


0t2


0t2

+4

Id1 $ Reduce 4

0t2

+4

t2 $ Reduce 2

0t2

+4

e6 $ Reduce 1

0e7 $ Accept


1 :e→ t +e2 :e→ t3 : t→Id ∗ t4 : t→Id

State Action Goto

Id + ∗ $ e t

0 s1 7 21 r4 s3 r42 s4 r23 s1 54 s1 6 25 r3 r36 r17 X

Stack Input Action



0Id1


0Id1

∗3

Id1 +Id$ Reduce 4

0Id1

∗3

t5 +Id$ Reduce 3

Here, we push a t with state 5. Thiseffectively “backs up” the LR(0)automaton and runs it over the newlyadded nonterminal.

In state 5 with an upcoming +, theaction is “reduce 3.”


0t2


0t2

+4

Id1 $ Reduce 4

0t2

+4

t2 $ Reduce 2

0t2

+4

e6 $ Reduce 1

0e7 $ Accept


1 :e→ t +e2 :e→ t3 : t→Id ∗ t4 : t→Id

State Action Goto

Id + ∗ $ e t

0 s1 7 21 r4 s3 r42 s4 r23 s1 54 s1 6 25 r3 r36 r17 X

Stack Input Action



0Id1


0Id1

∗3

Id1 +Id$ Reduce 4

0Id1

∗3

t5 +Id$ Reduce 3


This time, we strip off the RHS for rule3, Id∗ t, exposing state 0, so we push at with state 2.

0t2


0t2

+4

Id1 $ Reduce 4

0t2

+4

t2 $ Reduce 2

0t2

+4

e6 $ Reduce 1

0e7 $ Accept


1 :e→ t +e2 :e→ t3 : t→Id ∗ t4 : t→Id

State Action Goto

Id + ∗ $ e t

0 s1 7 21 r4 s3 r42 s4 r23 s1 54 s1 6 25 r3 r36 r17 X

Stack Input Action



0Id1


0Id1

∗3

Id1 +Id$ Reduce 4

0Id1

∗3

t5 +Id$ Reduce 3


0t2


0t2

+4

Id1 $ Reduce 4

0t2

+4

t2 $ Reduce 2

0t2

+4

e6 $ Reduce 1

0e7 $ Accept

Names, Objects, and Bindings

Object 1

Object 2

Object 3

Object 4

Name 1

Name 2

Name 3

Name 4

binding

binding

binding

binding

binding

Typical Stack Layout

↑ higher addresses

argument 2argument 1

return address ← frame pointerold frame pointer

saved registerslocal variables

temporaries/arguments← stack pointer

↓ growth of stack

Executing fib(3)

int fib(int n) {int tmp1, tmp2, tmp3;tmp1 = n < 2;if (!tmp1) goto L1;return 1;

L1: tmp1 = n - 1;tmp2 = fib(tmp1);


L3: tmp1 = tmp2 + tmp3;return tmp1;

}

n = 3SP

Executing fib(3)





}

n = 3

return addresslast frame pointertmp1 = 2tmp2 =tmp3 =n = 2

FP

SP

Executing fib(3)





}

n = 3



FP

SP

Executing fib(3)





}

n = 3



return addresslast frame pointertmp1 = 1tmp2 =tmp3 =

FP

SP

Executing fib(3)





}

n = 3


return addresslast frame pointertmp1 = 0tmp2 = 1tmp3 =n = 0

FP

SP

Executing fib(3)





}

n = 3




FP

SP

Executing fib(3)





}

n = 3


return addresslast frame pointertmp1 = 2tmp2 = 1tmp3 = 1

FP

SP

Executing fib(3)





}

n = 3


FP

SP

Executing fib(3)





}

n = 3



FP

SP

Executing fib(3)





}

n = 3

return addresslast frame pointertmp1 = 3← resulttmp2 = 2tmp3 = 1

FP

SP

Implementing Nested Functions with Static Links

let a x s =

let b y =

let c z = z + s in

let d w = c (w+1) in

d (y+1) in (* b *)

let e q = b (q+1) in

e (x+1) (* a *)

What does “a 5 42” evaluate to?

(static link)x = 5s = 42

a:


let a x s =

let b y =

let c z = z + s in


d (y+1) in (* b *)


e (x+1) (* a *)



a:

(static link)q = 6

e:


let a x s =

let b y =

let c z = z + s in


d (y+1) in (* b *)


e (x+1) (* a *)



a:

(static link)q = 6

e:

(static link)y = 7b:


let a x s =

let b y =

let c z = z + s in


d (y+1) in (* b *)


e (x+1) (* a *)



a:

(static link)q = 6

e:


(static link)w = 8

d:


let a x s =

let b y =

let c z = z + s in


d (y+1) in (* b *)


e (x+1) (* a *)



a:

(static link)q = 6

e:


(static link)w = 8

d:

(static link)z = 9

c:

Static vs. Dynamic Scope

program example;var a : integer; (* Outer a *)

procedure seta;begin

a := 1 (* Which a does this change? *)end

procedure locala;var a : integer; (* Inner a *)begin

setaend

begina := 2;if (readln() = ’b’)

localaelse

seta;writeln(a)

end

C’s Types: Base Types/Pointers

Base types match typical processor

Typical sizes: 8 16 32 64char short int long

float double

Pointers (addresses)

int *i; /* i is a pointer to an int */char **j; /* j is a pointer to a pointer to a char */

C’s Types: Arrays, Functions

Arrays

char c[10]; /* c[0] ... c[9] are chars */double a[10][3][2]; /* array of 10 arrays of 3 arrays of 2 doubles */

Functions

/* function of two arguments returning a char */char foo(int, double);

C’s Types: Structs and Unions

Structures: each field has own storagestruct box {

int x, y, h, w;char *name;

};

Unions: fields share same memoryunion token {int i;double d;char *s;

};

Composite Types: Records

A record is an object with a collection of fields, each with apotentially different type. In C,

struct rectangle {int n, s, e, w;char *label;color col;struct rectangle *next;

};

struct rectangle r;r.n = 10;r.label = "Rectangle";

Applications of Records

Records are the precursors of objects:

Group and restrict what can be stored in an object, but not whatoperations they permit.

Can fake object-oriented programming:

struct poly { ... };

struct poly *poly_create();void poly_destroy(struct poly *p);void poly_draw(struct poly *p);void poly_move(struct poly *p, int x, int y);int poly_area(struct poly *p);

Composite Types: Variant Records

A record object holds all of its fields. A variant record holds only oneof its fields at once. In C,

union token {int i;float f;char *string;

};

union token t;t.i = 10;t.f = 3.14159; /* overwrites t.i */char *s = t.string; /* returns gibberish */

Applications of Variant Records

A primitive form of polymorphism:

struct poly {int x, y;int type;union { int radius;

int size;float angle; } d;

};

If poly.type == CIRCLE, use poly.d.radius.

If poly.type == SQUARE, use poly.d.size.

If poly.type == LINE, use poly.d.angle.


Modern processors have byte-addressable memory.

0

1

2

3

The IBM 360 (c. 1964) helpedto popularizebyte-addressable memory.

Many data types (integers, addresses, floating-point numbers) arewider than a byte.

16-bit integer: 1 0

32-bit integer: 3 2 1 0


Modern memory systems readdata in 32-, 64-, or 128-bitchunks:

3 2 1 0

7 6 5 4

11 10 9 8

Reading an aligned 32-bit value isfast: a single operation.

3 2 1 0

7 6 5 4

11 10 9 8

It is harder to read an unalignedvalue: two reads plus shifting

3 2 1 0

7 6 5 4

11 10 9 8

6 5 4 3

SPARC prohibits unalignedaccesses.

MIPS has special unalignedload/store instructions.

x86, 68k run more slowly withunaligned accesses.

PaddingTo avoid unaligned accesses, the C compiler pads the layout ofunions and records.

Rules:

Ï Each n-byte object must start on a multiple of n bytes (nounaligned accesses).

Ï Any object containing an n-byte object must be of size mn forsome integer m (aligned even when arrayed).

struct padded {int x; /* 4 bytes */char z; /* 1 byte */short y; /* 2 bytes */char w; /* 1 byte */

};

x x x x

y y z

w

struct padded {char a; /* 1 byte */short b; /* 2 bytes */short c; /* 2 bytes */

};

b b a

c c

Arrays

Most languages provide array types:

char i[10]; /* C */

character(10) i ! FORTRAN

i : array (0..9) of character; -- Ada

var i : array [0 .. 9] of char; { Pascal }

Array Address Calculation

In C,

struct foo a[10];

a[i] is at a+ i∗sizeof(struct foo)

struct foo a[10][20];

a[i][j] is at a+ (j+20∗ i)∗sizeof(struct foo)

⇒ Array bounds must be known to access 2D+ arrays

Allocating Arrays in C++

int a[10]; /* static */

void foo(int n){int b[15]; /* stacked */int c[n]; /* stacked: tricky */int d[]; /* on heap */vector<int> e; /* on heap */

d = new int[n*2]; /* fixes size */e.append(1); /* may resize */e.append(2); /* may resize */

}

Allocating Fixed-Size Arrays

Local arrays with fixed size are easy to stack.

void foo(){int a;int b[10];int c;

}

return address ← FPa

b[0]...

b[9]c ← FP + 12

Allocating Variable-Sized Arrays

Variable-sized local arrays aren’t as easy.

void foo(int n){int a;int b[n];int c;

}


b[0]...

b[n-1]c ← FP + ?

Doesn’t work: generated code expects a fixed offset for c. Evenworse for multi-dimensional arrays.

Allocating Variable-Sized Arrays

As always:add a level of indirection

void foo(int n){int a;int b[n];int c;

}


b-ptr

c

b[0]

...b[n-1]

Variables remain constant offset from frame pointer.


struct f {int x, y;

} foo = { 0, 1 };

struct b {int x, y;

} bar;

bar = foo;

Is this legal in C?


struct f {int x, y;

} foo = { 0, 1 };

typedef struct f f_t;

f_t baz;

baz = foo;

Legal because f_t is an alias for struct f.

Ordering Within Expressions

What code does a compiler generate for

a = b + c + d;

Most likely something like

tmp = b + c;a = tmp + d;

(Assumes left-to-right evaluation of expressions.)

Order of EvaluationWhy would you care?

Expression evaluation can have side-effects.

Floating-point numbers don’t behave like numbers.

Side-effects

int x = 0;

int foo() {x += 5;return x;

}

int bar() {int a = foo() + x + foo();return a;

}

What does bar() return?

GCC returned 25.

Sun’s C compiler returned 20.

C says expression evaluation order is implementation-dependent.

Side-effects

int x = 0;

int foo() {x += 5;return x;

}

int bar() {int a = foo() + x + foo();return a;

}

What does bar() return?

GCC returned 25.

Sun’s C compiler returned 20.

C says expression evaluation order is implementation-dependent.

Side-effects

Java prescribes left-to-right evaluation.

class Foo {

static int x;

static int foo() {x += 5;return x;

}

public static void main(String args[]) {int a = foo() + x + foo();System.out.println(a);

}

}

Always prints 20.

Short-Circuit Evaluation

When you write

if (disaster_could_happen)avoid_it();

elsecause_a_disaster();

cause_a_disaster() is not called whendisaster_could_happen is true.

The if statement evaluates its bodies lazily: only when necessary.

The section operator ? : does this, too.

cost = disaster_possible ? avoid_it() : cause_it();

Logical Operators

In Java and C, Boolean logical operators“short-circuit” to provide this facility:

if (disaster_possible || case_it()) { ... }

cause_it() only called if disaster_possible is false.

The && operator does the same thing.

Useful when a later test could cause an error:

int a[10];

if (i => 0 && i < 10 && a[i] == 0) { ... }

Unstructured Control-Flow

Assembly languages usually provide three types of instructions:

Pass control to next instruction:

add, sub, mov, cmp

Pass control to another instruction:

jmp rts

Conditionally pass control next or elsewhere:

beq bne blt

Unstructured Control-FlowBEQ A

B:

JMP C

A:

BEQ D

C:

BEQ B

D:

BNE B

RTS

Structured Control-Flow

The “object-oriented languages” of the 1960s and 70s.

Structured programming replaces the evil goto with structured(nested) constructs such as

for

while

break

return

continue

do .. while

if .. then .. else

Gotos vs. Structured Programming

A typical use of a goto is building a loop. In BASIC:

10 PRINT I20 I = I + 130 IF I < 10 GOTO 10

A cleaner version in C using structured control flow:

do {printf("%d\n", i);i = i + 1;

} while ( i < 10 )

An even better version

for (i = 0 ; i < 10 ; i++)printf("%d\n", i);


Break and continue leave loops prematurely:

for ( i = 0 ; i < 10 ; i++ ) {if ( i == 5 ) continue;if ( i == 8 ) break;printf("%d\n", i);

}

i = 0;Again:if (!(i < 10)) goto Break;if ( i == 5 ) goto Continue;if ( i == 8 ) goto Break;printf("%d\n", i);

Continue: i++; goto Again;Break:

Escaping from Loops

Java allows you to escape from labeled loops:

a: for (int i = 0 ; i < 10 ; i++)for ( int j = 0 ; j < 10 ; j++) {

System.out.println(i + "," + j);if (i == 2 && j == 8) continue a;if (i == 8 && j == 4) break a;

}


Pascal has no “return” statement for escaping fromfunctions/procedures early, so goto was necessary:

procedure consume_line(var line : string);beginif line[i] = ’%’ then goto 100;(* .... *)

100:end

In C and many others, return does this for you:

void consume_line(char *line) {if (line[0] == ’%’) return;

}

Multi-way Branching

switch (s) {case 1: one(); break;case 2: two(); break;case 3: three(); break;case 4: four(); break;}

switch (s) {case 1: goto One;case 2: goto Two;case 3: goto Three;case 4: goto Four;

}goto Break;

One: one(); goto Break;Two: two(); goto Break;Three: three(); goto Break;Four: four(); goto Break;Break:

Switch sends control to one of the case labels. Break terminates thestatement. Really just a multi-way goto:

Implementing multi-way branches


Obvious way:

if (s == 1) { one(); }else if (s == 2) { two(); }else if (s == 3) { three(); }else if (s == 4) { four(); }

Reasonable, but we can sometimes do better.

Implementing multi-way branches

If the cases are dense, a branch table is more efficient:


A branch table written using a GCC extension:

/* Array of addresses of labels */static void *l[] = { &&L1, &&L2, &&L3, &&L4 };

if (s >= 1 && s <= 4)goto *l[s-1];

goto Break;L1: one(); goto Break;L2: two(); goto Break;L3: three(); goto Break;L4: four(); goto Break;Break:

Recursion and Iteration

To compute10∑

i=0f (i) in C,

the most obvious technique is iteration:

double total = 0;for ( i = 0 ; i <= 10 ; i++ )total += f(i);

But this can also be defined recursively

double sum(int i, double acc){if (i <= 10)

return sum(i+1, acc + f(i));else

return acc;}

sum(0, 0.0);

Tail-Recursion and Iteration

int gcd(int a, int b) {if ( a==b ) return a;else if ( a > b ) return gcd(a-b,b);else return gcd(a,b-a);

}

Notice: no computation follows any recursive calls.

Stack is not necessary: all variables “dead” after the call.

Local variable space can be reused. Trivial since the collection ofvariables is the same.

Works in O’Caml, too

let rec gcd a b =if a = b then aelse if a > b then gcd (a - b) belse gcd a (b - a)

Tail-Recursion and Iteration

int gcd(int a, int b) {if ( a==b ) return a;else if ( a > b ) return gcd(a-b,b);else return gcd(a,b-a);

}

Can be rewritten into:

int gcd(int a, int b) {start:if ( a==b ) return a;else if ( a > b ) a = a-b; goto start;else b = b-a; goto start;

}

Good compilers, especially those for functional languages, identifyand optimize tail recursive functions.

Less common for imperative languages, but gcc -O was able tohandle this example.

Applicative- and Normal-Order Evaluationint p(int i) {

printf("%d ", i);return i;

}

void q(int a, int b, int c){int total = a;printf("%d ", b);total += c;

}

q( p(1), 2, p(3) );

What does this print?

Applicative: arguments evaluated before function is called.

Result: 1 3 2

Normal: arguments evaluated when used.

Result: 1 2 3

Applicative- vs. and Normal-Order

Most languages use applicative order.

Macro-like languages often use normal order.

#define p(x) (printf("%d ",x), x)

#define q(a,b,c) total = (a), \printf("%d ", (b)), \total += (c)

q( p(1), 2, p(3) );

Prints 1 2 3.

Some functional languages also use normal order evaluation toavoid doing work. “Lazy Evaluation”

Argument Evaluation Order

C does not define argument evaluation order:

int p(int i) {printf("%d ", i);return i;

}

int q(int a, int b, int c) {}

q( p(1), p(2), p(3) );

Might print 1 2 3, 3 2 1, or something else.

This is an example of nondeterminism.

Nondeterminism

Nondeterminism is not the same as random:

Compiler usually chooses an order when generating code.

Optimization, exact expressions, or run-time values may affectbehavior.

Bottom line: don’t know what code will do, but often know set ofpossibilities.

int p(int i) { printf("%d ", i); return i; }int q(int a, int b, int c) {}q( p(1), p(2), p(3) );

Will not print 5 6 7. It will print one of

1 2 3, 1 3 2, 2 1 3, 2 3 1, 3 1 2, 3 2 1

Stack-Based IR: Java Bytecode

int gcd(int a, int b) {while (a != b) {

if (a > b)a -= b;

elseb -= a;

}return a;

}

# javap -c Gcd

Method int gcd(int, int)0 goto 19

3 iload_1 // Push a4 iload_2 // Push b5 if_icmple 15 // if a <= b goto 15

8 iload_1 // Push a9 iload_2 // Push b10 isub // a - b11 istore_1 // Store new a12 goto 19

15 iload_2 // Push b16 iload_1 // Push a17 isub // b - a18 istore_2 // Store new b

19 iload_1 // Push a20 iload_2 // Push b21 if_icmpne 3 // if a != b goto 3

24 iload_1 // Push a25 ireturn // Return a

Stack-Based IRs

Advantages:

Ï Trivial translation of expressions

Ï Trivial interpreters

Ï No problems with exhausting registers

Ï Often compact

Disadvantages:

Ï Semantic gap between stack operations and modern registermachines

Ï Hard to see what communicates with what

Ï Difficult representation for optimization

Register-Based IR: Mach SUIF

int gcd(int a, int b) {while (a != b) {

if (a > b)a -= b;

elseb -= a;

}return a;

}

gcd:gcd._gcdTmp0:sne $vr1.s32 <- gcd.a,gcd.bseq $vr0.s32 <- $vr1.s32,0btrue $vr0.s32,gcd._gcdTmp1 // if !(a != b) goto Tmp1

sl $vr3.s32 <- gcd.b,gcd.aseq $vr2.s32 <- $vr3.s32,0btrue $vr2.s32,gcd._gcdTmp4 // if !(a<b) goto Tmp4

mrk 2, 4 // Line number 4sub $vr4.s32 <- gcd.a,gcd.bmov gcd._gcdTmp2 <- $vr4.s32mov gcd.a <- gcd._gcdTmp2 // a = a - bjmp gcd._gcdTmp5

gcd._gcdTmp4:mrk 2, 6sub $vr5.s32 <- gcd.b,gcd.amov gcd._gcdTmp3 <- $vr5.s32mov gcd.b <- gcd._gcdTmp3 // b = b - a

gcd._gcdTmp5:jmp gcd._gcdTmp0

gcd._gcdTmp1:mrk 2, 8ret gcd.a // Return a

Register-Based IRs

Most common type of IR

Advantages:

Ï Better representation for register machines

Ï Dataflow is usually clear

Disadvantages:

Ï Slightly harder to synthesize from code

Ï Less compact

Ï More complicated to interpret

Optimization In Action

int gcd(int a, int b) {while (a != b) {if (a < b) b -= a;else a -= b;

}return a;

}

GCC on SPARC

gcd: save %sp, -112, %spst %i0, [%fp+68]st %i1, [%fp+72]

.LL2: ld [%fp+68], %i1ld [%fp+72], %i0cmp %i1, %i0bne .LL4nopb .LL3nop

.LL4: ld [%fp+68], %i1ld [%fp+72], %i0cmp %i1, %i0bge .LL5nopld [%fp+72], %i0ld [%fp+68], %i1sub %i0, %i1, %i0st %i0, [%fp+72]b .LL2nop

.LL5: ld [%fp+68], %i0ld [%fp+72], %i1sub %i0, %i1, %i0st %i0, [%fp+68]b .LL2nop

.LL3: ld [%fp+68], %i0retrestore

GCC -O7 on SPARC

gcd: cmp %o0, %o1be .LL8nop

.LL9: bge,a .LL2sub %o0, %o1, %o0sub %o1, %o0, %o1

.LL2: cmp %o0, %o1bne .LL9nop

.LL8: retlnop

Typical Optimizations

Ï Folding constant expressions1+3 → 4

Ï Removing dead codeif (0) { . . . } → nothing

Ï Moving variables from memory to registers

ld [%fp+68], %i1sub %i0, %i1, %i0st %i0, [%fp+72]

→ sub %o1, %o0, %o1

Ï Removing unnecessary data movement

Ï Filling branch delay slots (Pipelined RISC processors)

Ï Common subexpression elimination

Machine-Dependent vs. -Independent Optimization

No matter what the machine is, folding constants and eliminatingdead code is always a good idea.

a = c + 5 + 3;if (0 + 3) {b = c + 8;

}

→ b = a = c + 8;

However, many optimizations are processor-specific:

Ï Register allocation depends on how many registers themachine has

Ï Not all processors have branch delay slots to fill

Ï Each processor’s pipeline is a little different

Basic Blocks

int gcd(int a, int b) {while (a != b) {if (a < b) b -= a;else a -= b;

}return a;

}

lower→

A: sne t, a, bbz E, tslt t, a, bbnz B, tsub b, b, ajmp C

B: sub a, a, bC: jmp AE: ret a

split→

A: sne t, a, bbz E, t

slt t, a, bbnz B, t

sub b, b, ajmp C

B: sub a, a, b

C: jmp A

E: ret a

The statements in a basic block all run if the first one does.

Starts with a statement following a conditional branch or is abranch target.

Usually ends with a control-transfer statement.

Control-Flow GraphsA CFG illustrates the flow of control among basic blocks.

A:sne t, a, bbz E, t

slt t, a, bbnz B, t

sub b, b, ajmp C

B:sub a, a, b

C:jmp A

E:ret a

A:sne t, a, bbz E, t

slt t, a, bbnz B, t

sub b, b, ajmp C

B:sub a, a, b

E:ret a

C:jmp A

Separate Compilation and Linking

foo

foo.o

foo.s

foo.c

Compiler

Assembler

Linker

bar.o

bar.s

bar.c

cc

as

libc.a

printf.o

Archiver

fopen.o malloc.o

ar

ld

Linking

Goal of the linker is to combine the disparatepieces of the program into a coherent whole.

file1.c:

#include <stdio.h>char a[] = "Hello";extern void bar();

int main() {bar();

}

void baz(char *s) {printf("%s", s);

}

file2.c:

#include <stdio.h>extern char a[];

static char b[6];

void bar() {strcpy(b, a);baz(b);

}

libc.a:

intprintf(char *s, ...){

/* ... */}

char *strcpy(char *d,

char *s){

/* ... */}

Linking

Goal of the linker is to combine the disparatepieces of the program into a coherent whole.

file1.c:


int main() {bar();

}


}

file2.c:

#include <stdio.h>extern char a[];

static char b[6];


}

libc.a:

intprintf(char *s, ...){

/* ... */}

char *strcpy(char *d,

char *s){

/* ... */}

Linking

file1.o

a=“Hello”

main()

baz()

a.out.text segment

main()

baz()

bar()

.data segment

a=“Hello”

.bss segment

char b[6]

file2.o

char b[6]

bar()

.textCode of program

.dataInitialized data

.bssUninitialized data“Block Started by

Symbol”

Linking

file1.o

a=“Hello”

main()

baz()

a.out.text segment

main()

baz()

bar()

.data segment

a=“Hello”

.bss segment

char b[6]

file2.o

char b[6]

bar()

.textCode of program

.dataInitialized data

.bssUninitialized data“Block Started by

Symbol”

Object Files

Relocatable: Many need to be pasted together. Final in-memoryaddress of code not known when program is compiled

Object files contain

Ï imported symbols (unresolved “external” symbols)

Ï relocation information (what needs to change)

Ï exported symbols (what other files may refer to)

Object Files

file1.c:


int main() {bar();

}


}

exported symbols

imported symbols

Object Files

file1.c:#include <stdio.h>char a[] = "Hello";extern void bar();

int main() {bar();

}


}

# objdump -x file1.oSections:Idx Name Size VMA LMA Offset Algn0 .text 038 0 0 034 2**21 .data 008 0 0 070 2**32 .bss 000 0 0 078 2**03 .rodata 008 0 0 078 2**3

SYMBOL TABLE:0000 g O .data 006 a0000 g F .text 014 main0000 *UND* 000 bar0014 g F .text 024 baz0000 *UND* 000 printf

RELOCATION RECORDS FOR [.text]:OFFSET TYPE VALUE0004 R_SPARC_WDISP30 bar001c R_SPARC_HI22 .rodata0020 R_SPARC_LO10 .rodata0028 R_SPARC_WDISP30 printf

Object Files

file1.c:#include <stdio.h>char a[] = "Hello";extern void bar();

int main() {bar();

}


}

# objdump -d file1.o0000 <main>:0: 9d e3 bf 90 save %sp, -112, %sp4: 40 00 00 00 call 4 <main+0x4>

4: R_SPARC_WDISP30 bar8: 01 00 00 00 nopc: 81 c7 e0 08 ret10: 81 e8 00 00 restore

0014 <baz>:14: 9d e3 bf 90 save %sp, -112, %sp18: f0 27 a0 44 st %i0, [ %fp + 0x44 ]1c: 11 00 00 00 sethi %hi(0), %o0

1c: R_SPARC_HI22 .rodata20: 90 12 20 00 mov %o0, %o0

20: R_SPARC_LO10 .rodata24: d2 07 a0 44 ld [ %fp + 0x44 ], %o128: 40 00 00 00 call 28 <baz+0x14>

28: R_SPARC_WDISP30 printf2c: 01 00 00 00 nop30: 81 c7 e0 08 ret34: 81 e8 00 00 restore

Before and After Linkingint main() {bar();

}


}

Ï Combine object files

Ï Relocate each function’s code

Ï Resolve previously unresolved symbols

0000 <main>:0: 9d e3 bf 90 save %sp, -112, %sp4: 40 00 00 00 call 4 <main+0x4>

4: R_SPARC_WDISP30 bar8: 01 00 00 00 nopc: 81 c7 e0 08 ret10: 81 e8 00 00 restore

0014 <baz>:14: 9d e3 bf 90 save %sp, -112, %sp18: f0 27 a0 44 st %i0, [ %fp + 0x44 ]1c: 11 00 00 00 sethi %hi(0), %o0

1c: R_SPARC_HI22 .rodata Unresolved symbol20: 90 12 20 00 mov %o0, %o0

20: R_SPARC_LO10 .rodata24: d2 07 a0 44 ld [ %fp + 0x44 ], %o128: 40 00 00 00 call 28 <baz+0x14>

28: R_SPARC_WDISP30 printf2c: 01 00 00 00 nop30: 81 c7 e0 08 ret34: 81 e8 00 00 restore

105f8

Code starting address changed

<main>:105f8: 9d e3 bf 90 save %sp, -112, %sp105fc: 40 00 00 0d call 10630 <bar>

10600: 01 00 00 00 nop10604: 81 c7 e0 08 ret10608: 81 e8 00 00 restore

1060c <baz>:1060c: 9d e3 bf 90 save %sp, -112, %sp10610: f0 27 a0 44 st %i0, [ %fp + 0x44 ]10614: 11 00 00 41 sethi %hi(0x10400), %o0

10618: 90 12 23 00 or %o0, 0x300, %o0

1061c: d2 07 a0 44 ld [ %fp + 0x44 ], %o110620: 40 00 40 62 call 207a8

10624: 01 00 00 00 nop10628: 81 c7 e0 08 ret1062c: 81 e8 00 00 restore

Linking Resolves Symbolsfile1.c:#include <stdio.h>char a[] = "Hello";extern void bar();

int main() {bar();

}


}

file2.c:#include <stdio.h>extern char a[];

static char b[6];


}

105f8 <main>:105f8: 9d e3 bf 90 save %sp, -112, %sp105fc: 40 00 00 0d call 10630 <bar>10600: 01 00 00 00 nop10604: 81 c7 e0 08 ret10608: 81 e8 00 00 restore

1060c <baz>:1060c: 9d e3 bf 90 save %sp, -112, %sp10610: f0 27 a0 44 st %i0, [ %fp + 0x44 ]10614: 11 00 00 41 sethi %hi(0x10400), %o010618: 90 12 23 00 or %o0, 0x300, %o0 ! "%s"1061c: d2 07 a0 44 ld [ %fp + 0x44 ], %o110620: 40 00 40 62 call 207a8 ! printf10624: 01 00 00 00 nop10628: 81 c7 e0 08 ret1062c: 81 e8 00 00 restore

10630 <bar>:10630: 9d e3 bf 90 save %sp, -112, %sp10634: 11 00 00 82 sethi %hi(0x20800), %o010638: 90 12 20 a8 or %o0, 0xa8, %o0 ! 208a8 <b>1063c: 13 00 00 81 sethi %hi(0x20400), %o110640: 92 12 63 18 or %o1, 0x318, %o1 ! 20718 <a>10644: 40 00 40 4d call 20778 ! strcpy10648: 01 00 00 00 nop1064c: 11 00 00 82 sethi %hi(0x20800), %o010650: 90 12 20 a8 or %o0, 0xa8, %o0 ! 208a8 <b>10654: 7f ff ff ee call 1060c <baz>10658: 01 00 00 00 nop1065c: 81 c7 e0 08 ret10660: 81 e8 00 00 restore10664: 81 c3 e0 08 retl10668: ae 03 c0 17 add %o7, %l7, %l7


The 1980s GUI/WIMP revolution required many large libraries (theAthena widgets, Motif, etc.)

Under a static linking model, each executable using a library gets acopy of that library’s code.

Address 0:

libXaw.alibX11.a

xeyes

libXaw.alibX11.a

xterm libXaw.alibX11.axclock

Wasteful: running many GUI programs at once fills memory withnearly identical copies of each library.

Something had to be done: another level of indirection.


The 1980s GUI/WIMP revolution required many large libraries (theAthena widgets, Motif, etc.)

Under a static linking model, each executable using a library gets acopy of that library’s code.

Address 0:

libXaw.alibX11.a

xeyes

libXaw.alibX11.a

xterm libXaw.alibX11.axclock

Wasteful: running many GUI programs at once fills memory withnearly identical copies of each library.

Something had to be done: another level of indirection.

Shared Libraries: First Attempt

Most code makes assumptions about its location.

First solution (early Unix System V R3) required each shared libraryto be located at a unique address:

Address 0:

libXm.so

libXaw.so libXaw.solibX11.so libX11.so libX11.so

netscapexterm

xeyes

Obvious disadvantage: must ensure each new shared librarylocated at a new address.

Works fine if there are only a few libraries; tended to discouragetheir use.

Shared Libraries: First Attempt

Most code makes assumptions about its location.

First solution (early Unix System V R3) required each shared libraryto be located at a unique address:

Address 0:

libXm.so

libXaw.so libXaw.solibX11.so libX11.so libX11.so

netscapexterm

xeyes

Obvious disadvantage: must ensure each new shared librarylocated at a new address.

Works fine if there are only a few libraries; tended to discouragetheir use.

Shared Libraries

Problem fundamentally is that each program may need to seedifferent libraries each at a different address.

libXaw.solibX11.so

xeyes

libXaw.solibX11.so

xterm

libXm.so

libX11.so

netscape

Position-Independent Code

Solution: Require the code for libraries to be position-independent.Make it so they can run anywhere in memory.

As always, add another level of indirection:

Ï All branching is PC-relative

Ï All data must be addressed relative to a base register.

Ï All branching to and from this code must go through a jumptable.

Position-Independent Code for bar()

Normal unlinkedcode

save %sp, -112, %spsethi %hi(0), %o0R_SPARC_HI22 .bss

mov %o0, %o0R_SPARC_LO10 .bss

sethi %hi(0), %o1R_SPARC_HI22 a

mov %o1, %o1R_SPARC_LO10 a

call 14R_SPARC_WDISP30 strcpy

nopsethi %hi(0), %o0R_SPARC_HI22 .bss

mov %o0, %o0R_SPARC_LO10 .bss

call 24R_SPARC_WDISP30 baz

nopretrestore

gcc -fpic -shared

save %sp, -112, %spsethi %hi(0x10000), %l7call 8e0 ! add PC to %l7add %l7, 0x198, %l7ld [ %l7 + 0x20 ], %o0ld [ %l7 + 0x24 ], %o1

call 10a24

Actually just a stub

! strcpy

nopld [ %l7 + 0x20 ], %o0

call

call is PC-relative

10a3c ! baz

nopretrestore

Prolog Execution

Facts

nerd(X) :- techer(X).techer(stephen).

↓Query

?- nerd(stephen). → Search (Execution)

↓Result

yes

Simple Searching

Starts with the query:

?- nerd(stephen).

Can we convince ourselves that nerd(stephen) is true given thefacts we have?

techer(stephen).nerd(X) :- techer(X).

First says techer(stephen) is true. Not helpful.

Second says that we can conclude nerd(X) is true if we canconclude techer(X) is true. More promising.

Simple Searching

techer(stephen).nerd(X) :- techer(X).

?- nerd(stephen).

Unifying nerd(stephen) with the head of the second rule,nerd(X), we conclude that X = stephen.

We’re not done: for the rule to be true, we must find that all itsconditions are true. X = stephen, so we want techer(stephen)to hold.

This is exactly the first clause in the database; we’re satisfied. Thequery is simply true.

More Clever Searchingtecher(stephen).techer(todd).nerd(X) :- techer(X).

?- nerd(X).

“Tell me about everybody who’s provably a nerd.”

As before, start with query. Rule only interesting thing.

Unifying nerd(X) with nerd(X) is vacuously true, so we need toestablish techer(X).

Unifying techer(X) with techer(stephen) succeeds, setting X =stephen, but we’re not done yet.

Unifying techer(X) with techer(todd) also succeeds, setting X =todd, but we’re still not done.

Unifying techer(X) with nerd(X) fails, returning no.

The Prolog Environment

Database consists of Horn clauses. (“If a is true and b is true and ...and y is true then z is true”.)

Each clause consists of terms, which may be constants, variables, orstructures.

Constants: foo my_Const + 1.43

Variables: X Y Everybody My_var

Structures: rainy(rochester)teaches(edwards, cs4115)

Structures and Functors

A structure consists of a functor followed by an open parenthesis, alist of comma-separated terms, and a close parenthesis:

“Functor”

bin_tree(

paren must follow immediately

foo, bin_tree(bar, glarch) )

What’s a structure? Whatever you like.

A predicate nerd(stephen)A relationship teaches(edwards, cs4115)A data structure bin(+, bin(-, 1, 3), 4)

Unification

Part of the search procedure that matches patterns.

The search attempts to match a goal with a rule in the database byunifying them.

Recursive rules:

Ï A constant only unifies with itself

Ï Two structures unify if they have the same functor, the samenumber of arguments, and the corresponding arguments unify

Ï A variable unifies with anything but forces an equivalence

Unification ExamplesThe = operator checks whether two structures unify:

| ?- a = a.yes % Constant unifies with itself| ?- a = b.no % Mismatched constants| ?- 5.3 = a.no % Mismatched constants| ?- 5.3 = X.X = 5.3 ? ; % Variables unifyyes| ?- foo(a,X) = foo(X,b).no % X=a required, but inconsistent| ?- foo(a,X) = foo(X,a).X = a % X=a is consistentyes| ?- foo(X,b) = foo(a,Y).X = aY = b % X=a, then b=Yyes| ?- foo(X,a,X) = foo(b,a,c).no % X=b required, but inconsistent

The Searching Algorithm

search(goal g, variables e)for each clause

in the order they appear

h :- t1, . . . , tn in the databasee = unify(g, h, e)if successful,

for each term

in the order they appear

t1, . . . , tn,e = search(tk, e)

if all successful, return ereturn no

Note: This pseudo-code ignores one very important part of thesearching process!

Order Affects Efficiency

edge(a, b). edge(b, c).edge(c, d). edge(d, e).edge(b, e). edge(d, f).

path(X, X).

path(X, Y) :-edge(X, Z), path(Z, Y).

Consider the query| ?- path(a, a).

path(a,a)

path(a,a)=path(X,X)

X=a

yes

Good programming practice: Put the easily-satisfied clauses first.

Order Affects Efficiency


path(X, Y) :-edge(X, Z), path(Z, Y).

path(X, X).


Will eventually producethe right answer, but willspend much more timedoing so.

path(a,a)

path(a,a)=path(X,Y)

X=a Y=a

edge(a,Z)

edge(a,Z) = edge(a,b)

Z=b

path(b,a)

...

Order Can Cause Infinite Recursion


path(X, Y) :-path(X, Z), edge(Z, Y).

path(X, X).


path(a,a)Goal

path(a,a)=path(X,Y)Unify

X=a Y=aImplies

Subgoalpath(a,Z)

path(a,Z) = path(X,Y)

X=a Y=Z

path(a,Z)

path(a,Z) = path(X,Y)

X=a Y=Z

...

edge(Z,Z)

edge(Z,a)

Prolog as an Imperative Language

A declarative statement such as

P if Q and R and S

can also be interpreted procedurally as

To solve P, solve Q, then R, then S.

This is the problem with the last pathexample.

path(X, Y) :-path(X, Z), edge(Z, Y).

“To solve P, solve P. . . ”

go :- print(hello_),print(world).

| ?- go.hello_worldyes

CutsWays to shape the behavior of thesearch:

Ï Modify clause and termorder.Can affect efficiency,termination.

Ï “Cuts”Explicitly forbidding furtherbacktracking.

When the search reaches a cut(!), it does no more backtracking.techer(stephen) :- !.techer(todd).nerd(X) :- techer(X).

| ?- nerd(X).

X = stephen

yes

Lambda Expressions

Function application written in prefix form. “Add four and five” is

(+ 4 5)

Evaluation: select a redex and evaluate it:

(+ (∗ 5 6) (∗ 8 3)) → (+ 30 (∗ 8 3))→ (+ 30 24)→ 54

Often more than one way to proceed:

(+ (∗ 5 6) (∗ 8 3)) → (+ (∗ 5 6) 24)→ (+ 30 24)→ 54

Simon Peyton Jones, The Implementation of Functional Programming Languages,Prentice-Hall, 1987.

Function Application and Currying

Function application is written as juxtaposition:

f x

Every function has exactly one argument. Multiple-argumentfunctions, e.g., +, are represented by currying, named after HaskellBrooks Curry (1900–1982). So,

(+ x)

is the function that adds x to its argument.

Function application associates left-to-right:

(+ 3 4) = ((+ 3) 4)→ 7

Lambda Abstraction

The only other thing in the lambda calculus is lambda abstraction:a notation for defining unnamed functions.

(λx . + x 1)

( λ x . + x 1 )↑ ↑ ↑ ↑ ↑ ↑

That function of x that adds x to 1

The Syntax of the Lambda Calculus

expr ::= expr expr| λ variable . expr| constant| variable| (expr)

Constants are numbers and built-in functions;variables are identifiers.

Beta-Reduction

Evaluation of a lambda abstraction—beta-reduction—is justsubstitution:

(λx . + x 1) 4 → (+ 4 1)→ 5

The argument may appear more than once

(λx . + x x) 4 → (+ 4 4)→ 8

or not at all

(λx . 3) 5 → 3

Free and Bound Variables

(λx . + x y) 4

Here, x is like a function argument but y is like a global variable.

Technically, x occurs bound and y occurs free in

(λx . + x y)

However, both x and y occur free in

(+ x y)

Beta-Reduction More Formally

(λx . E) F →β E′

where E′ is obtained from E by replacing every instance of x thatappears free in E with F .

The definition of free and bound mean variables have scopes. Onlythe rightmost x appears free in

(λx . + (− x 1)) x 3

so

(λx . (λx . + (− x 1)) x 3) 9 → (λ x . + (− x 1)) 9 3→ + (− 9 1) 3→ + 8 3→ 11

Alpha-Conversion

One way to confuse yourself less is to do α-conversion: renaming aλ argument and its bound variables.

Formal parameters are only names: they are correct if they areconsistent.

(λx . (λx . + (− x 1)) x 3) 9 ↔ (λx . (λy . + (− y 1)) x 3) 9→ ((λy . + (− y 1)) 9 3)→ (+ (− 9 1) 3)→ (+ 8 3)→ 11

Beta-Abstraction and Eta-Conversion

Running β-reduction in reverse, leaving the “meaning” of a lambdaexpression unchanged, is called beta abstraction:

+ 4 1 ← (λx . + x 1) 4

Eta-conversion is another type of conversion that leaves “meaning”unchanged:

(λx . + 1 x) ↔η (+ 1)

Formally, if F is a function in which x does not occur free,

(λx . F x) ↔η F

Reduction Order

The order in which you reduce things can matter.

(λx . λy . y)((λz . z z) (λz . z z)

)Two things can be reduced:

(λz . z z) (λz . z z)

(λx . λy . y) ( · · · )

However,

(λz . z z) (λz . z z) → (λz . z z) (λz . z z)

(λx . λy . y) ( · · · ) → (λy . y)

Normal Form

A lambda expression that cannot be β-reduced is in normal form.Thus,

λy . y

is the normal form of

(λx . λy . y)((λz . z z) (λz . z z)

)Not everything has a normal form. E.g.,

(λz . z z) (λz . z z)

can only be reduced to itself, so it never produces an non-reducibleexpression.

Normal Form

Can a lambda expression have more than one normal form?

Church-Rosser Theorem I: If E1 ↔ E2, then there existsan expression E such that E1 → E and E2 → E.

Corollary. No expression may have two distinct normal forms.

Proof. Assume E1 and E2 are distinct normal forms for E: E ↔ E1

and E ↔ E2. So E1 ↔ E2 and by the Church-Rosser Theorem I, theremust exist an F such that E1 → F and E2 → F . However, since E1 andE2 are in normal form, E1 = F = E2, a contradiction.

Normal-Order Reduction

Not all expressions have normal forms, but is there a reliable way tofind the normal form if it exists?

Church-Rosser Theorem II: If E1 → E2 and E2 is in normal form,then there exists a normal order reduction sequence from E1 to E2.

Normal order reduction: reduce the leftmost outermost redex.

Normal-Order Reduction

((λx .

((λw . λz . + w z) 1

)) ((λx . x x) (λx . x x)

)) ((λy . + y 1) (+ 2 3)

)

leftmost outermost

leftmost innermostλx

λw

λz

+ wz

1

λx

x x

λx

x x

λy

+ y

1 + 2

3

Recursion

Where is recursion in the lambda calculus?

FAC =(λn . IF (= n 0) 1

(∗ n

(FAC (− n 1)

)))

This does not work: functions are unnamed in the lambda calculus.But it is possible to express recursion as a function.

FAC = (λn . . . . FAC . . .)←β (λf . (λn . . . . f . . .)) FAC= H FAC

That is, the factorial function, FAC, is a fixed point of the(non-recursive) function H :

H = λf . λn . IF (= n 0) 1 (∗ n (f (− n 1)))

RecursionLet’s invent a function Y that computes FAC from H , i.e., FAC = Y H :

FAC = H FACY H = H (Y H)

FAC 1 = Y H 1= H (Y H) 1= (λf . λn . IF (= n 0) 1 (∗ n (f (− n 1)))) (Y H) 1→ (λn . IF (= n 0) 1 (∗ n ((Y H) (− n 1)))) 1→ IF (= 1 0) 1 (∗ 1 ((Y H) (− 1 1)))→ ∗ 1 (Y H 0)= ∗ 1 (H (Y H) 0)= ∗ 1 ((λf . λn . IF (= n 0) 1 (∗ n (f (− n 1)))) (Y H) 0)→ ∗ 1 ((λn . IF (= n 0) 1 (∗ n (Y H (− n 1)))) 0)→ ∗ 1 (IF (= 0 0) 1 (∗ 0 (Y H (− 0 1))))→ ∗ 1 1→ 1

The Y Combinator

Here’s the eye-popping part: Y can be a simple lambda expression.

Y =

= λf .(λx . f (x x)

) (λx . f (x x)

)Y H =

(λf .

(λx . f (x x)

) (λx . f (x x)

))H

→ (λx . H (x x)

) (λx . H (x x)

)→ H

((λx . H (x x)

) (λx . H (x x)

))↔ H

( (λf .

(λx . f (x x)

) (λx . f (x x)

))H

)= H (Y H)

“Y: The function that takes a function f and returns f (f (f (f (· · · ))))”

Processes and Threads

Process

Separate address space

Explicit inter-processcommunication

Synchronization part ofcommunication

Operating system calls: fork(),wait()

Thread

Shared address spaces

Separate PC and stacks

Communication is throughshared memory

Synchronization done explicitly

Library calls, e.g., pthreads

Dot Product

#include <stdio.h>

int main(){double a[256], b[256], sum;int i, n = 256;

for (i = 0 ; i < n ; i++) {a[i] = i * 0.5;b[i] = i * 2.0;

}

sum = 0.0;

for (i = 0 ; i < n ; i++ )sum += a[i]*b[i];

printf("sum = %f\n", sum);return 0;

}

Dot Product

#include <omp.h>#include <stdio.h>

int main(){double a[256], b[256], sum;int i, n = 256;

for (i = 0 ; i < n ; i++) {a[i] = i * 0.5;b[i] = i * 2.0;

}

sum = 0.0;# pragma omp parallel for reduction(+:sum)for (i = 0 ; i < n ; i++ )sum += a[i]*b[i];

printf("sum = %f\n", sum);return 0;

}

OpenMP version

gcc -fopenmp -o dot dot.c

OpenMP pragma tells thecompiler to

Ï Execute the loop’siterations in parallel(multiple threads)

Ï Sum each thread’sresults

What’s going on?#include <omp.h>#include <stdio.h>

int main() {int i, n = 16;

# pragma omp parallel for \shared(n) private(i)

for (i = 0 ; i < n ; i++)printf("%d: %d\n",omp_get_thread_num(), i);

return 0;}

“parallel for”: Split for loopiterations into multiple threads“shared(n)”: Share variable nacross threads“private(i)”: Each thread has aseparate i variable

Run 1

1: 41: 51: 61: 72: 82: 92: 102: 110: 03: 123: 133: 143: 150: 10: 20: 3

Run 2

3: 123: 133: 143: 151: 41: 51: 61: 72: 82: 92: 102: 110: 00: 10: 20: 3

Run 3

0: 00: 10: 20: 33: 123: 133: 143: 151: 41: 51: 61: 72: 82: 92: 102: 11

Fork-Join Task ModelSpawn tasks in parallel, run each to completion, collect the results.

Master Thread

Fork

Join

Child threads

Parallel Regions


int main(){

# pragma omp parallel{ /* Fork threads */

printf("This is thread %d\n",omp_get_thread_num());

} /* Join */

printf("Done.\n");

return 0;}

$ ./parallelThis is thread 1This is thread 3This is thread 2This is thread 0Done.$ ./parallelThis is thread 2This is thread 1This is thread 3This is thread 0Done.$ OMP_NUM_THREADS=8 ./parallelThis is thread 0This is thread 4This is thread 1This is thread 5This is thread 3This is thread 6This is thread 2This is thread 7Done.

Work Sharing: For Construct


int main(){int i;

# pragma omp parallel{

# pragma omp forfor (i = 0 ; i < 8 ; i++)printf("A %d[%d]\n",

omp_get_thread_num(), i);# pragma omp for

for (i = 0 ; i < 8 ; i++)printf("B %d[%d]\n",

omp_get_thread_num(), i);}

return 0;}

$ ./forA 3[6]A 3[7]A 0[0]A 0[1]A 2[4]A 2[5]A 1[2]A 1[3]B 1[2]B 1[3]B 0[0]B 0[1]B 3[6]B 3[7]B 2[4]B 2[5]

Work Sharing: Nested Loops

Outer loop’s index private by default.Inner loop’s index must be set private.


int main(){int i, j;

# pragma omp parallel for private(j)for (i = 0 ; i < 4 ; i++)for (j = 0 ; j < 2 ; j++)

printf("A %d[%d,%d]\n",omp_get_thread_num(), i, j);

return 0;}

p$ ./for-nestedA 3[3,0]A 3[3,1]A 1[1,0]A 1[1,1]A 2[2,0]A 2[2,1]A 0[0,0]A 0[0,1]

$ ./for-nestedA 3[3,0]A 3[3,1]A 1[1,0]A 1[1,1]A 0[0,0]A 0[0,1]A 2[2,0]A 2[2,1]

Summing a Vector: Critical regions#pragma omp parallel forfor (i = 0 ; i < N ; i++)

sum += a[i]; // RACE: sum is shared

int main(){double sum = 0.0, local, a[10];int i;for ( i = 0 ; i < 10 ; i++)a[i] = i * 3.5;

# pragma omp parallel \shared(a, sum) private(local)

{local = 0.0;

# pragma omp forfor (i = 0 ; i < 10 ; i++)local += a[i];

# pragma omp critical{ sum += local; }

}printf("%g\n", sum);return 0;

}

Without the critical directive:$ ./sum157.5$ ./sum73.5

With #pragma omp critical:$ ./sum157.5$ ./sum157.5

Summing a Vector: Reduction


int main(){double sum = 0.0, a[10];int i;for ( i = 0 ; i < 10 ; i++)

a[i] = i * 3.5;

# pragma omp parallel \shared(a) reduction(+:sum)

{# pragma omp for

for (i = 0 ; i < 10 ; i++)sum += a[i];

}

printf("%g\n", sum);return 0;

}

$ ./sum-reduction157.5

Barriers#include <omp.h>#include <stdio.h>

int main(){int x = 2;

# pragma omp parallel shared(x){

int tid = omp_get_thread_num();if (tid == 0)x = 5;

elseprintf("A: th %d: x=%d\n",

tid, x);

# pragma omp barrier

printf("B: th %d: x=%d\n",tid, x);

}return 0;

}

$ ./barrierA: th 2: x=2

Old value of x

A: th 3: x=2A: th 1: x=2B: th 1: x=5B: th 0: x=5B: th 2: x=5B: th 3: x=5

$ ./barrierA: th 2: x=2A: th 3: x=5

New value of x

A: th 1: x=2B: th 1: x=5B: th 2: x=5B: th 3: x=5B: th 0: x=5

Documents

Stephen A. Edwards - Columbia Universitysedwards/classes/2014/w4115-summer-cvn/final-review.pdfDeterministic Finite Automata Restricted form of NFAs: ˇ No state has a transition on