1. http://www.cs.cornell.edu/courses/ cs612/2002sp/projects/
CS612 Term Projects
cs612/2002sp/projects/

2. Expectations picking a partner(s) that you can work with,
meeting with your project supervisor at least once a week.
doing background reading on the topic,
designed novel algorithms or systems to solve the problem,
building an prototype implementation of the system,
presenting your work and results to the class,
writing and submit a report about your activities, and
[optionally] developing a web page that describes your work.

3. Project Deadlines Friday, March 26th -- Signup for a project
There will be two presentations on each of these dates.
4/25 -???, then ???
4/30 -???, then ???
5/1 - ???, then ???
Friday, May 3rd -- Turn in your final reports and implementations.

4. The Projects Tile Size Selection
Empirical Optimization of Sparse Kernels
Value Prediction
Language Extensions for the Mobile Object Layer
Computationally Intensive Mobile Computing
Computing Reuse Distance Exactly
Design your own project

5. Tile Size Selection

6. Tile Size Selection
State of the art in tiling imperfectly nested codes
Product space approach can be used for converting imperfect to perfect nesting
Framework can be used for tiling imperfectly nested loops
Heuristics exist for selecting tile sizes for perfectly nested loops.
It remains for someone to put it all together.

7. Tile Size Selection The goals of the project are the following :-
Develop a tile-size determination algorithm for imperfectly-nested loops.
Compare the performance of the code obtained by tiling with the tile-size predicted by your algorithm to the performance with the "optimal" tile-size.

8. Empirical Optimization of Sparse Kernels
MVM has very little reuse.
Toledo: restructuring Sparse MVM can double its performance on RS6000.
Sparse MVM is often MMM, which can be blocked. But, block size is determined by sparsity and blocks are very small.

9. Empirical Optimization of Sparse Kernels
Project goals:
Evaluate the effective of Toledo’s optimizations on a non-RS6000 architecture.
Use an empirical optimization framework (e.g., ATLAS) to generate highly optimized kernels for performing small MMM’s.
Evaluate the effectively of combined optimizations on a number of different sparse matrices.

10. Value Prediction
80% of load values in some codes can be predicted using relatively simple schemes.
E.g., the address of the load instruction to determine the predicted value; for example, the processor can guess that the value will be the same as the value that was last returned by that load instruction
However, we are not aware of any careful studies that explain why value prediction works so well on such codes

11. Value Prediction Novice project goals:
Understand the state of the art in value prediction
Design and evaluate a value prediction scheme
Advanced project goals:
Understand how compiler technology can be used to improve the performance of value prediction.
Implement a prototype compiler system to implement your strategies.

12. Language Extensions for the Mobile Object Layer
The Mobile Object Layer (MOL),
Part of the Portable Runtime Environment for Mobile Applications (PREMA)
Supports a global distributed object space
Provides correct and efficient protocols for message forwarding and communication between migrating objects.
Designed to work with dynamic load balancing libraries.
Lean, language-independent. Easy to port and maintain.

13. Language Extensions for the Mobile Object Layer
Current interface uses C
Ineffective for C++
Class declarations
Object creation
// Params are passed to main() mol_init(argc, argv); mol_msg_handler_t handlers[] = {myHandler}; mol_register_msg_handlers(handlers, 1); Foo* pFoo = new Foo(); mol_mobile_ptr_t mp = mol_create_mobile_ptr(pFoo);
struct Foo { void method(void* pParam); }; // This handler must be defined // externally to the struct, or else // be static. void myHandler(int nSrc, mol_mobile_ptr_t mp, void* pObject, void* pData, int nSize, void* pArg) { Foo* pFoo = (Foo*)pObject; pFoo->method(pData); }
Method invocation
void* pData = <something>; mol_message(mp, myHandler, pData, <data size>, MOL_DELAYED_HANDLER, NULL);

14. Language Extensions for the Mobile Object Layer
What would be nice:
Declaration/creation
MobileObject<Foo>* pObject = new MobileObject<Foo>;
Method invocation
pObject->method(pData);

15. Language Extensions for the Mobile Object Layer
The goals of the project are the following:
Design and implement a C++-friendly interface for the MOL.
Either template based, or
Using syntactic extensions.
Compare C++ programs written using the C-style interface with your C++ interface

16. Computationally Intensive Mobile Computing
Remote
Local
Should we execute locally or remotely?

17. Computationally Intensive Mobile Computing
The goals of the project are the following :-
Develop a simple model for predicting the performance of local and remote execution.
Build a restructuring compiler to generate programs for local and remote execution.

18. Computing Reuse Distance Exactly
Can we compute reuse distance exactly at compile time?

19. Computing Reuse Distance Exactly

20. Computing Reuse Distance Exactly
The goals of the project is to develop a method for using Presberger formulae for exactly computing the reuse distance between references in a simple loop nest.

21. Design your own project
Several critera,
It must be developed with oversight from Paul.
It must be substantial enough to keep you busy until the end of the semester, but not so ambitious that you cannot possibly complete it on time.
It must have something to do with compilers, scientific computing, or high-performance computing.

22. Threaded-C
Project idea: Restructuring compiler to parallelize loops to
Threaded-C