Final Examination CS 4501 Spring 2012

Transcription

1 Final Examination CS 4501 Spring 2012 This final examination tests your knowledge of, and your ability to communicate coherently about, high-level concepts from the Compilers Practicum. It is an essay test. Complete the exam by writing text in the boxes provided, saving the file as uvaid.doc (e.g., wrw6y.doc), and ing the resulting file back to me. There are 10 pages on this exam, including this one. There are six questions, but you should only answer five of them. Skip one question. The final page has extra credit questions. This exam is open book: you may use any reference you like. You may spend as much time as you like on the exam, but it is due MONDAY MAY 7th AT 11:59pm. For the essay questions, include the most important relevant details you deem necessary. Demonstrating knowledge is more important than English prose; if you can get your ideas across in an outline or other loose format, feel free to do so. The most important part is to convince us that you have understood and retained the material and key concepts. You should skip one question. Do not answer all eight of the questions in this exam. Type your name here: Type your UVA ID here: Westley Weimer wrw6y Q1. Code Generation?? / 10 pts Q2. Register Allocation?? / 10 pts Q3. Calling Conventions?? / 10 pts Q4. Dataflow Analysis?? / 10 pts Q5. Strength Reduction?? / 10 pts Q6. Developing New Optimizations?? / 10 pts Extra Credit?? Failed to name file or type own name/id correctly Total -5 pts?? / 50 pts (recall: skip one question)

2 1 Code Generation [5 points] Recall the simple stack machine code generation function from the code generation slides: cgen(e1 - e2) = cgen(e1) push r1 cgen(e2) pop t1 sub r1 <- t1 r1 Now consider one of the opsem rules for the general if statement: Write a cgen function for if e1 then e2. Your cgen function should handle both cases (i.e., e1 may be True or False).

3 [5 points] Now consider the for loop. Shown below is one of the (corrected) opsem rules from Midterm 2: Write a cgen function that handles for loops. The code produced by your cgen function should work correctly regardless of the number of iterations performed at run-time (i.e., regardless of the run-time values of e_low and e_high).

4 2 Register Allocation [5 points] A liveness analysis of a Cool program produced the following variable interferences (i.e., found that the following subsets of variables were live at the same times). Recall that if two variables interfere (i.e., if they are live at the same time) then they cannot share the same register. A interferes with: G B C H B interferes with: A D E G C interferes with: A D F H D interferes with: B C E F E interferes with: B D G F I F interferes with: C D E H I G interferes with: A B E H I H interferes with: A C F G I I interferes with: G E F H Draw the register interference graph corresponding to this situation. Label each node with its variable name. (Pasting in a scan or picture is fine.) [5 points] Given only four registers (r1, r2, r3, r4), assign a register to each variable such that no register is shared between live variables. You may spill at most one variable onto the stack (just write STACK" as its register value.) A B C D E F G H I

5 3 Calling Conventions Consider the following Cool program: class Main inherits Object { foo(p1 : Int, p2 : Int, p3: Int, p4: Int) : Int { let x : Int 50 in p3 + p4 + bar(p1 + 1, p2 + 1, p3 + 1) } ; bar(p1 : Int, p2 : Int, p3 : Int) : Int { let y : Int p3 in 3 + biz(p1, y) } ; biz(p1 : Int, p2 : Int) : Int { p1 + p2 (* last evaluated statement *) } ; main() : Object { let a : Int 10, b : Int 20, c : Int 30, d : Int 40 in { 2 + foo(a,b,c,d); } } ; }; Suppose we compile this program using a new and different calling convention. At the last evaluated statement, the stack contains the values given below. Use this information to answer the following questions about the choices made by the compiler to generate code from the above Cool program. Hint: in this convention, not all parameters are passed on the stack. Instead, two registers are used to pass parameters to a method and must be saved before calling another method. Address Value [2 points] At which address is the local variable y stored? [2 points] Are method parameters evaluated left-to-right or right-to-left? [2 points] List the values of the three return addresses on the stack [2 points] Describe what is being stored at address uninitialized 1995 uninitialized [2 points] Why are addresses 1994 and 1995 uninitialized?

6 4 Intraprocedural Data Flow Analysis [10 points] In this question you are asked to perform data flow analysis and optimization within a single function. Using the control flow graph below, perform only constant propagation, constant folding, and dead code elimination. Perform these optimizations until no more changes can be made to the CFG. Write your optimized version of each basic block on the next page. Assume all variables are local and previously declared. Your analysis should follow the transfer functions described in class, not your intuition (i.e., you may be able to a better job than a compiler would, but in this question we'd like you to simulate the process described in class).

7 Replace the text of each block with the final result after optimization. Block 1 a = 2 b = 4 c = 2 d = 8 hrr!= drr Block 2 e = b / 2 d = d + 2 f = e 2 a = c + 2 b = b + f d <= 16 Block 3 a = a + 2 e = d / 4 e = e 2 c = 5 x > 10 Block 4 b = a / 2 c = c + 1 b = b + 2 c < 5 Block 5 d = 7 e = 9 d f = b 1 Block 6 x = b + a y = c + 2 z = 2 * e

8 5 Strength Reduction [10 points] Consider the addition of a shift left instruction to Cool assembly: li r1 <- 13 ;; r1 stores (13) shft r2 <- r1 1 ;; r2 stores (26) shft r3 <- r1 3 ;; r3 stores (104) This instruction shifts each bit left by the supplied integer argument. Zeros pad the least significant bits and the most significant bits are truncated. This instruction costs 3 cycles. As a reminder, below are the cycle costs for other Cool assembly arithmetic operations. add sub mul div shft li r r r dest op1 op2 = 1 cycle r r r dest op1 op2 = 1 cycle r r r dest op1 op2 = 10 cycles r r r dest op1 op2 = 40 cycles r dest r src integer = 3 cycles r dest integer = 1 cycle [10 points] Perform strength reductions on the following expressions to meet the target number of cycles. Your answer should use only the above 6 instructions and up to four registers (r0, r1, r2, r3) with the result stored in r0. Ignore overflow, the stack, and power consumption. (a) r0 * 64 Target: < 10 cycles (b) r0 * 18 Target: < 6 cycles (c) r1 + r1 + r1 + r1 Target: < 3 cycles (d) (r1*r2)+(r1*r2)+(r1*r2)+(r1*r2) Target: < 14 Cycles (e) 4095*r0*r0 + 13*r0-255*r0 * 16*r *r0*r0-9*r0 Target: < 13 cycles

9 6 Developing New Optimizations [10 points] Under our current performance model for Cool assembly, all system calls incur a cost of 1000 cycles, compared to 1 cycle for most instructions. This assumption is somewhat grounded in reality, as system calls to write output typically take orders of magnitude more time than basic arithmetic. As an illustrative example, the following Cool program is extremely costly for its size: let I : Int 0 in while I < 100 loop { I I + 1; out_int(i); out_string( ); } pool; out_string( \n ); However, this blanket cost assumption for system calls is less appropriate for internal methods like like String.concat, String.length, and String.substr. Since Cool assembly has no internal support for manipulating strings without using syscall, an operation as simple as finding the length of a zero-length string costs 1000 cycles. Consider a version of Cool assembly where calls to concat cost X cycles where X is the length of the resulting concatenated string, calls to length take 1 cycle, and calls to substr take max(1; indx end - indx begin ) cycles. However, calls to IO.out string and IO.out int remain 1000 cycles. Describe a compiler optimization for our modified version of Cool assembly that would significantly reduce the cost of successive calls to out string and out int as shown above. Your answer should include a brief description of how you would implement this optimization, why it would reduce cycle costs, and any conditions where the optimization would fail to improve performance.

10 Extra Credit [1 point] What was your favorite things about the Compilers Practicum? Your least favorite thing? [1 point] What was your favorite thing about Adam Brady as an instructor? What suggestions would you offer for improvement? [1 point] What trivia question should be included in the next iteration of Programming Languages? Include the answer.