Sethi–Ullman algorithm


In computer science, the Sethi–Ullman algorithm is an algorithm named after Ravi Sethi and Jeffrey D. Ullman, its inventors, for translating abstract syntax trees into machine code that uses as few registers as possible.

Overview

When generating code for arithmetic expressions, the compiler has to decide which is the best way to translate the expression in terms of number of instructions used as well as number of registers needed to evaluate a certain subtree. Especially in the case that free registers are scarce, the order of evaluation can be important to the length of the generated code, because different orderings may lead to larger or smaller numbers of intermediate values being spilled to memory and then restored. The Sethi–Ullman algorithm fulfills the property of producing code which needs the fewest instructions possible as well as the fewest storage references. Please note that the algorithm succeeds as well if neither commutativity nor associativity hold for the expressions used, and therefore arithmetic transformations can not be applied. The algorithm also does not take advantage of common subexpressions or apply directly to expressions represented as general directed acyclic graphs rather than trees.

Simple Sethi–Ullman algorithm

The simple Sethi–Ullman algorithm works as follows :
  1. Traverse the abstract syntax tree in pre- or postorder
  2. # For every non-constant leaf node, assign a 1 if it is the left child of its parent else assign a 0. For every constant leaf node, assign a 0.
  3. # For every non-leaf node n, assign the number of registers needed to evaluate the respective subtrees of n. If the number of registers needed in the left subtree are not equal to the number of registers needed in the right subtree, the number of registers needed for the current node n is max. If l r, then the number of registers needed for the current node is r + 1.
  4. Code emission
  5. # If the number of registers needed to compute the left subtree of node n is bigger than the number of registers for the right subtree, then the left subtree is evaluated first. If the right subtree needs more registers than the left subtree, the right subtree is evaluated first accordingly. If both subtrees need equal as much registers, then the order of evaluation is irrelevant.

    Example

For an arithmetic expression, the abstract syntax tree looks like this:
=
/ \
a *
/ \
/ \
+ +
/ \ / \
/ \ d 3
+ *
/ \ / \
b c f g
To continue with the algorithm, we need only to examine the arithmetic expression, i.e. we only have to look at the right subtree of the assignment '=':
*
/ \
/ \
+ +
/ \ / \
/ \ d 3
+ *
/ \ / \
b c f g
Now we start traversing the tree, assigning the number of registers needed to evaluate each subtree :
*2
/ \
/ \
+2 +1
/ \ / \
/ \ d1 30
+1 *1
/ \ / \
b1 c0f1 g0
From this tree it can be seen that we need 2 registers to compute the left subtree of the '*', but only 1 register to compute the right subtree. Nodes 'c' and 'g' do not need registers for the following reasons: If T is a tree leaf, then the number of registers to evaluate T is either 1 or 0 depending whether T is a left or a right subtree. Therefore we shall start to emit code for the left subtree first, because we might run into the situation that we only have 2 registers left to compute the whole expression. If we now computed the right subtree first, we would then need a register to hold the result of the right subtree while computing the left subtree, therefore needing 3 registers concurrently. Computing the left subtree first needs 2 registers, but the result can be stored in 1, and since the right subtree needs only 1 register to compute, the evaluation of the expression can do with only 2 registers left.

Advanced Sethi–Ullman algorithm

In an advanced version of the Sethi–Ullman algorithm, the arithmetic expressions are first transformed, exploiting the algebraic properties of the operators used.