Parallel algorithms for expression evaluation

Part1. Simultaneous substitution method (SimSub) Part2. A parallel pebble game

Example 1: expression evaluation

Summing the numbers 2, 1, 3, 2, 1, 3, 2, 1 we can write a sequential program

x1 = 2; x2 = x1+1; x3 = x2+3; x4 = x3+2;

x5 = x4+1; x6 = x5+3; x7 = x6+2; x8=x7+1

Simultaneous Substitutions Method (SimSub)

x = Expression(y) and y = Expression1 a variable y can be substituted by its expression or by its value if it is known (if Expression1 is a constant)assume we have a sequence of expressions defining variables, each expression is of a constant size variables are numbered and i-th expression depends only on variables with

numbers smaller than i e.g. x1=4 x2=x1+5 x3=x1+x2*7 x4=x2*x3

One parallel step: for each expression substitute its variables by their expression if it is safe;safe means that corresponding expression has at most one variable

Example: summing the numbers 2, 1, 3, 2, 1, 3, 2, 1 we can write a sequential programx1 = 2; x2 = x1+1; x3 = x2+3; x4 = x3+2; x5 = x4+1; x6 = x5+3; x7 = x6+2

after parallel step 1x1 = 2; x2 = 3; x3 = x1+4; x4 = x2+5; x5 = x3+3; x6 = x4+4; x7 = x5+5

after parallel step 2x1 = 2; x2 = 3; x3 = 6; x4 = 8; x5 = x1+7; x6 = x2+9; x7 = x3+8

after parallel step 2x1 = 2; x2 = 3; x3 = 6; x4 = 8; x5 = 9; x6 = 12; x7 = 14

output = sum = x7

In this way we can sum 1024 numbers in 10 rounds

Tree-contraction========================================

Parallel algorithms related to expression evaluation correspond to parallel algorithmic technique called tree-contraction

===============================================Tree-contraction is used in parallel expression evaluation Since the structure of a expression is a tree there are different tree-contraction techniquesBasic operations are:

- redirecting edges of the tree - removing nodes marking (pebbling) nodes - creating additional edges

the final aim is to guarantee that logarithmic number of contractions is sufficient

Tree-contraction related to SimSub algorithm

Example Substitutions method works in O(log n) time. In each iteration the active tree is reduced by 1/3 at least.

The active tree consists of nodes relevant to the output computation,

The root is the output variable (the last one).

Fn is the smallest tree which needs n iterations in tree contraction related to SimSub algorithm

Homework: is it good object for SimSub? Why?

How the SimSub algorithm works for general graphs ?

sometimes very poor (e.g. when computing Fibonacci numbers)

generally with n processors we need

n-1 iterations

-only one processor really works

each time, so the same can be done with a single processor

SimSub will terminate after

O(log (tree-size(graph)) iterations

for the dependency graph of Fibonacci numbers tree-size (number of paths) is exponential.

Other tree contraction method: parallel pebble game (PPG)

Parallel pebble game (PPG) works for full binary trees, full means each father has exactly 2 sons

Parallel pebble game on binary tree

Within the game each node v of the tree has associated with it similar node denoted by cond(v). At the outset of the game cond(v)=v, for all v During the game the pairs (v,cond(v)) can be thought of as additional edges

Node v is ”active” if and only if cond(v)v

Pebbling

Pebbling a node denotes the fact that in the current state of the game the processor associated with that node has sufficient information to evaluate the subtree rooted here

Three operationsactive, square and pebble

Activate for all non-leaf nodes v in parallel do

if v is not active and precisely one of its sons is pebbled thencond(v) becomes the other son

if v is not active and both sons are pebbled thencond(v) becomes one of the sons arbitrarily

Square

for all nodes v in parallel do cond(v) cond(cond(v)) Pebble for all nodes v in parallel do

if cond(v) is pebbled then pebble v

Key result

At the outset of the game only the leaves of the tree are pebbled. One composite move of the pebbling game is the sequence of individual operations

(activate, square, square, pebble)Theorem

Let T be a binary tree with n leaves. If initially only the leaves are pebbled then after log2n moves of the pebbling game the root of T becomes pebbled.

Example

activate

square

square pebbling

The application of the pebbling game

Consider the arithmetic expression ((3+(2*2))*3+5)We assign a processor to each non-leaf node of the tree.+

5*

+

3*

2 2

3

+

5*

+

3*

2 2

3

+

5*

+

3*

2 2

3

+

5*

+

3*

2 2

3

+

5*

+

3*

2 2

3

X*2

X+3

X*3X+5

3x+5

3x+92x+

3

2x

3(2x+3)+53(2x)+9

2x+3

2x

Evaluation of arithmetic expressions

Arithmetic expressions can be evaluated on a PRAM in O(log n) time using O(n) processors.