![ The dynamic programming algorithm proceeds
in three phases:
1. Compute bottom-up for each node n in the
expression tree T an array C of costs, in which
the ith component C[i] is the optional cost of
computing the sub-tree S rooted at n into a
register, assuming i registers are available for
the computation, for 1<= i <= r.](https://image.slidesharecdn.com/cd-201010092144/85/Dynamic-Programming-Code-Optimization-Algorithm-Compiler-Design-3-320.jpg)
![ Let us apply the dynamic programming algorithm to generate
optimal code for the syntax tree in Fig 8.26.
In the first phase, we compute the cost vectors shown at each
node.
To illustrate this cost computation, consider the cost vector at
the leaf a.
C[0], the cost of computing a into memory, is 0 since it is
already there.
C[l], the cost of computing a into a register, is 1 since we can
load it into a register with the instruction LD R0, a.
C[2], the cost of loading a into a register with two registers
available, is the same as that with one register available.
The cost vector at leaf a is therefore (0,1,1).](https://image.slidesharecdn.com/cd-201010092144/85/Dynamic-Programming-Code-Optimization-Algorithm-Compiler-Design-6-320.jpg)
Dynamic Programming Code-Optimization Algorithm (Compiler Design)
- 3. The dynamic programming algorithm proceeds in three phases: 1. Compute bottom-up for each node n in the expression tree T an array C of costs, in which the ith component C[i] is the optional cost of computing the sub-tree S rooted at n into a register, assuming i registers are available for the computation, for 1<= i <= r.
- 4. 1. Mentioned in previous slide 2. Traverse T, using the cost vectors to determine which sub-trees of T must ne computed into memory. 3. Traverse each tree using the cost vectors and associated instructions to generate the final target code. The code for the sub-trees computed into memory locations is generated first.
- 5. Consider a machine having two registers R0 and R1, and the following instructions, each of unit cost: LD Ri, Kj // Ri = Mj op Ri, Ri, Ri // Ri = Ri Op Rj op Ri, Ri, Mi // Ri = Ri Op Kj LD Ri, Ri // Ri = Ri ST Hi, Ri // Mi = Rj In these instructions, Ri is either R0 or R1, and Mi is a memory location. The operator op corresponds to an arithmetic operators.
- 6. Let us apply the dynamic programming algorithm to generate optimal code for the syntax tree in Fig 8.26. In the first phase, we compute the cost vectors shown at each node. To illustrate this cost computation, consider the cost vector at the leaf a. C[0], the cost of computing a into memory, is 0 since it is already there. C[l], the cost of computing a into a register, is 1 since we can load it into a register with the instruction LD R0, a. C[2], the cost of loading a into a register with two registers available, is the same as that with one register available. The cost vector at leaf a is therefore (0,1,1).
- 7. Consider the cost vector at the root. We first determine the minimum cost of computing the root with one and two registers available. The machine instruction ADD R0, R0, M matches the root, because the root is labeled with the operator +. Using this instruction, the minimum cost of evaluating the root with one register available is the minimum cost of computing its right subtree into memory, plus the minimum cost of computing its left subtree into the register, plus 1 for the instruction. No other way exists. The cost vectors at the right and left children of the root show that the minimum cost of computing the root with one register available is 5 + 2 + 1 = 8.
- 8. Now consider the minimum cost of evaluating the root with two registers available. Three cases arise depending on which instruction is used to compute the root and in what order the left and right sub- trees of the root are evaluated. Compute the left sub-tree with two registers available into register R0, compute the right sub- tree with one register available into register R1, and use the instruction ADD R0, R0, R1 to compute the root. This sequence has cost 2 + 5 + 1 = 8.
- 9. Compute the right sub-tree with two registers available into R1, compute the left sub-tree with one register available into R0, and use the instruction ADD R0, R0, R1. This sequence has cost 4 + 2 + 1 = 7. Compute the right sub-tree into memory location M, compute the left sub-tree with two registers available into register R0, and use the instruction ADD R0, R0, M. This sequence has cost 5 + 2 + 1 = 8. The second choice gives the minimum cost 7.
- 10. The minimum cost of computing the root into memory is determined by adding one to the minimum cost of computing the root with all registers avail-able; that is, we compute the root into a register and then store the result. The cost vector at the root is therefore (8,8,7). From the cost vectors we can easily construct the code sequence by making a traversal of the tree. From the tree in Fig. 8.26, assuming two registers are available, an optimal code sequence is
- 11. LD R0, c // R0 = c LD R1, d // R1 = d DIV R1, R1, e // R1 = R1 / e MUL R0, R0, R1 // R0 = R0 * R1 LD R1, a // R1 = a SUB R1, R1, b // R1 = R1 - b ADD R1, R1, R0 // R1 = R1 + R0 Dynamic programming techniques have been used in a number of compilers, including the second version of the portable C compiler, PCC2 . The technique facilitates retargeting because of the applicability of the dynamic programming technique to a broad class of machines.
- 12. Inspiration from Prof. Nidhi Shah Notes of CD Textbook of CD Images from Google Images