Advanced Compiler Design ( ) Fall Semester Project Proposal. Out: Oct 4, 2017 Due: Oct 11, 2017 (Revisions: Oct 18, 2017)

Size: px

Start display at page:

Download "Advanced Compiler Design ( ) Fall Semester Project Proposal. Out: Oct 4, 2017 Due: Oct 11, 2017 (Revisions: Oct 18, 2017)"

Darlene Watts
6 years ago
Views:

1 Advanced Compiler Design ( ) Fall Semester 2017 Project Proposal Out: Oct 4, 2017 Due: Oct 11, 2017 (Revisions: Oct 18, 2017) The goal of the project is to implement, test, and evaluate an advanced compiler optimization, program analysis or language feature. 1 General Concerns You may choose to implement an optimization technique or program analysis from the literature or a known feature from another similar programming language. However, to obtain the highest possible grade, you have to incorporate and experiment with your own ideas. Alternatively, you can come up with some ideas that (to your and to our knowledge) have not been implemented before. For example, this could be a specific combination of optimization techniques or a language feature that comes from a different domain or is new altogether. You are required to do an evaluation of your implementation. For optimizations, your evaluation will naturally be about performance. For language features, this is not necessarily the case. For example, if you implement interfaces, you may (and probably should) evaluate the performance of interface calls, but you may also evaluate the usability aspect, e.g., by comparing your design to other languages. 1

2 2 Schedule & Deliverables During the course of the project, you are required to provide various deliverables and presentations to show your progress. Project Proposal - Due: October 11, The project proposal is an outline of what you plan to achieve by the end of the semester. It has two forms: a written proposal with an extent of one to three pages and a three to five minute oral presentation Describe the objective of the project, the basic approach, your own ideas, and how you plan to evaluate your implementation. In addition, specify which parts you plan to complete for the milestone (see below). Please stick to these limits (number of pages, length of presentation). You will present your project proposal in class on the 11th of October, Submit a first version of the written proposal until 08:00 am on the same day (i.e., before the presentations) using your team s svn directory. Put the document into a file called projectplan.pdf and the slides (if you want to use any) into a file projectplan slides.pdf (.pptx is also ok). After the presentations, the assistants may give you feedback and ask you to adapt your proposal. After you receive the feedback you will have a couple of days to revise your proposal and submit a final version by October 18, The final version will be graded (and contribute towards your final grade, see the web page for details). You can meet the assistants on the 6th or 9th of October, 2017 to clarify any doubts that you may have and ask questions before the project proposal date. Please contact the assistants if you want to have a meeting. Milestone Presentation - Due: November 8, Four weeks after you have submitted your project proposal, you will present your first results. If you implement an optimization, an analysis, or a feature from the literature, the core parts of your implementation should be there. This allows you to spend the last six weeks for completing the implementation, experimenting with your own ideas and evaluating your project. The presentation will be oral and should take three to five minutes. Final Presentation - Tentative: December 20, At the end of the semester, you will give a final presentation of five to eight minutes, which will focus on the work of the last six weeks. You will present the results of the evaluation, the impact of your own ideas, and your conclusions. Project Report and Code - Tentative: January 5, After the final presentation, you will have time to finish your project by submitting a written report and the source code of your implementation. The report should be phrased as a scientific essay and should include some details about your implementation and evaluation. 2

3 The report must not exceed six pages of the template that will be provided on the course website. Your implementation should be correct and thoroughly tested. Unit tests, test programs, and any testing or evaluation infrastructure are part of the submission. Furthermore, we expect that the code will be well-structured and documented. 3 Project Examples This section presents some examples of possible projects. You are welcome to choose a project which is not in this list, either from the literature or based on your own ideas. Note that the listed examples are incomplete ideas, i.e., they will not give you the full grade for this course. They must be extended and combined with your own ideas. The complete ideas will be proposed and presented by you with the project proposal. Method Calls Optimization [JavaLi] Method resolution optimizations in the context of object oriented systems have been of interest to various research groups. The main idea behind these optimizations is to avoid the indirection necessary for resolving the method to be invoked for an object. Inline caching Method inlining Procedure cloning/specialization Note that you may have to perform some analysis (e.g., profiling, class hierarchy analysis) to apply these techniques. Literature. 1. Cooper et al., A Methodlogy for Procedure Cloning, Computer Languages, Volume 19, Arnold et al., A Comparative Study of Static and Profile-Based Heuristics for Inlining, DYNAMO 00 Function Memoization [JavaLi, Cetus] Memoization is the technique that aims at reducing execution time by saving the results of repeated computations with the same input. In this project, you will explore compiler level strategies to inject code in a program to perform memoization. For example, you can think of strategies to save the results of a function or the intermediate values produced in a basic block. 3

4 Literature. 1. Suresh et al., Compile-Time Function Memoization, CC Suresh et al., Intercepting functions for memoization, TACO Ding et al., A Compiler Scheme for Reusing Intermediate Computation Results, CGO Pugh et al., Incremental Computation via Function Caching, POPL 89 Object Layout and Allocation [JavaLi, Cetus] In this project, you investigate the interaction between the CPU architecture and the memory layout of objects. You will explore different strategies for representing objects in memory that differ from a simple linear layout of the fields. For example, you can think of strategies to fuse or split objects based on their access patterns or based on the ownership relationship between objects in a data structure. Literature. 1. Wimmer et al., Automatic Object Colocation Based on Read Barriers, JMLC Jaber et al., Data Structure-Aware Heap Partitioning, CC Chilimbi et al., Cache-Conscious Structure Definition, PLDI 99 Multiple Inheritance, Interfaces and Traits [JavaLi] JavaLi does not have interfaces, traits, and multiple inheritance. In this project, you implement one or more of these features in the JavaLi framework. This means that you will introduce a new kind of declaration types and perform additional semantic checks in the class or in one of its super classes. Your compiler must produce assembly code and derive object layouts for an efficient method dispatch and method execution. Try to get inspired by existing solutions, explore what are the implementation consequences from a compiler design point of view. Value Types for Javali [JavaLi] In contrast to normal classes, value types are user defined types with semantics similar to primitive types. Instances of value types may consist of multiple parts (like fields), but they do not have an identity. Value types are (also) interesting from a optimization point of view, because they can often be implemented more efficiently than classes. 4

5 Static and Dynamic Analysis [Cetus] Write a static and dynamic program analysis tool. The static part creates program statistics, such as the number of loops, parallel loops, number of shared, private, and reduction variables, etc. The dynamic part would instrument the program to determine execution times and other dynamic metrics of program sections of interest. The pass could include a performance predictor based on the results of the static and dynamic analysis. Another possibility is to present the statistics in a way that assist the software engineer in improving the parallel program. Cetus Transformation Pass [Cetus] Write a program transformation pass. One possibility is to extend one of the Cetus passes in an interesting way; e.g., run Cetus on a set of programs of your choice; see where the current passes fail to perform (private variables, induction variables, or reductions not recognized) and improve the pass to resolve the issue. Another possibility is to write a new pass that is able to detect the necessary parallelism in a program that Cetus fails to parallelize. Cetus Analysis [Cetus] This project aims at improving the analysis of Cetus for private variables, reduction variables and etc. For example, Cetus does not currently recognize private variables that are fields of a struct, or private variables that are declared in the global scope. Loop Pipelining [Cetus] A linear pipeline is a loop with cross-iteration dependences that can be partitioned into a sequence of stages such that every stage may depend only on previous stages. To parallelize such a loop we need to find the cross-iteration dependences, and then check if it is possible to partition the loop body into at least two stages. For example, if the last statement of the loop writes a variable that is read in the first statement (of the next loop iteration), then there is a single stage (no pipeline parallelism). Thus, if there exist at least two stages, the next step is to partition the loop body into a sequence of (load-balanced) stages that leads to good performance. This implies that the parallelization of a linear pipeline can be done if we know: a) which variables exhibit cross-iteration dependences and which are used only within a loop iteration, and b) how the loop body is partitioned into stages. Automatic Parallelization In this project, the compiler reads sequential (while) loops and automatically generates directives for those loops that can be parallelized by pipelining. Particularly, the directives must report the type of the variables used within the loop and must also partition the loop body into stages. The types must be similar to those used by OpenMP, e.g., private, shared, etc. The partitioning must be done using some heuristic function that estimates the execution time of 5

6 each stage. The list of private and shared variables is already given by Cetus; but it is necessary to check if the cross-iteration dependences of the loop form a linear pipeline (which is also required for partitioning). Therefore, the necessary information for the cross-iteration dependences is already in Cetus, but this information must be extracted and reported with directives that partition the loop body. Pipelining Transformation Pass This project reads sequential loops annotated with directives of the previous project and applies a transformation which generates parallel code according to some pipelining technique, e.g., PS-DSWP, LBPP, etc. All the information required by the transformation is given with directives. Literature. 1. Kamruzzaman et al., Load-balanced pipeline parallelism, SC Raman et al., Parallel-stage decoupled software pipelining, CGO 08 6

While waiting for the lecture to begin, please complete. the initial course questionnaire.

While waiting for the lecture to begin, please complete. the initial course questionnaire. SENG 475 & ECE 569A: Advanced Programming Techniques for Robust Efficient Computing (With C++) Michael Adams Department of Electrical and Computer Engineering University of Victoria Victoria, BC, Canada