-
Notifications
You must be signed in to change notification settings - Fork 14
Research Roadmap
This is a checklist for doing research on the ACCEPT project.
The page is organized into research "stages." The first stage is relatively well-defined and important for getting started, but the rest are all open-ended and do not need to go in any particular order.
The first step is to become familiar with the ACCEPT project: its theory and the implementation itself.
-
Read the ACCEPT paper draft. As background, it could also be helpful to read the EnerJ paper.
-
Set up and build the ACCEPT compiler. Follow the Building section of the documentation. This is very complicated software to set up, so this will almost certainly take longer than we initially expect.
-
Walk through the tutorial to get ACCEPT working with an initial (simple) application. This should not be a fully complex application; that will come later. This involves several substeps:
- Choose a simple application.
- Set up the build infrastructure (a Makefile) for the program.
- Make the program write the appropriate output to a file.
- Add ROI markers for timing.
- Write an output parser and quality metric (
eval.py). - Annotate the program for approximation. For now, this will just be a first-pass annotation set; it can be refined later after feedback from the tool.
- Interact with the ACCEPT analyses (
accept log,accept exp) to understand how approximations are applied based on annotations. - Refine the annotation set based on the compiler's feedback. Rinse and repeat.
- Collect results for a "final" annotation of the program and report on the findings.
There are two goals during this "familiarization" stage of the research. First, there's the obvious goal of getting you, the researcher, up to speed with the research direction and what we've built already. Second, and less obviously, you will help improve the usability and documentation of the system. Throughout the process, we want feedback from you on what works, what doesn't, what's clear, and what's confusing.
To that end, please keep notes about what was easy already and what was difficult. Whenever problems come up---either with the tool itself or with the documentation---we should make a note to fix those. Either send us an email or file an issue describing what we should do.
After this initial stage, there are many directions that the research can go depending on your interests. These are not mutually exclusive; they can be fruitfully combined and executed simultaneously.
In the first stage, you wrote and optimized a small program with ACCEPT. In this (potential) part of the project, you will find a full-scale, serious program and evaluate it with ACCEPT.
Perhaps the most challenging aspect of this project will be identifying a good application. Programs must be written in C and C++ and must exhibit some notion of approximability. They will ideally be computationally intensive, from "interesting" domains, and yet not so complex that they will be difficult to understand.
Good places to look for applications include the PARSEC benchmark suite, open-source GitHub repositories, and plain old Google.
During the course of experimenting with programs (small or large), it may be come apparent that ACCEPT should be applying an optimization that it currently doesn't. In this case, we should extend the infrastructure to be more powerful!
This will involve some learning about the LLVM compiler infrastructure, which forms the foundation for ACCEPT. You will design an optimization, document how it will apply safely based on ACCEPT's annotations, and implement it using our existing program analyses.
The programmer interface is a crucial component of ACCEPT. Programmers need insight into how optimizations apply and why. The ACCEPT log (the output of accept log) gives some insight into this, but it can become difficult to read for large applications.
Your job is to come up with better ideas for how to present feedback to the programmer. Maybe we can prioritize the output to sort it by importance? Maybe a visual representation would help? Implementing any of these strategies would help.
We want to make ACCEPT useful for laypeople. Now that you're an ACCEPT expert, can you teach the world to use it?
Your task it to write a script for and record a YouTube video that explains why ACCEPT is awesome and how someone can get started using it. We'll add this to the public documentation.