CS612 Term Projects
http://www.cs.cornell.edu/courses/
cs612/2002sp/projects/
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.
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.
The Projects
1.
2.
3.
4.
Tile Size Selection
Empirical Optimization of Sparse Kernels
Value Prediction
Language Extensions for the Mobile Object
Layer
5. Computationally Intensive Mobile Computing
6. Computing Reuse Distance Exactly
7. Design your own project
Tile Size Selection
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.
Tile Size Selection
The goals of the project are the following :1.Develop a tile-size determination algorithm
for imperfectly-nested loops.
2.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.
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.
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.
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
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.
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.
Language Extensions for the
Mobile Object Layer
• Current interface uses C
• Ineffective for C++
– Class declarations
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); }
– 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);
– Method invocation
void* pData = <something>;
mol_message(mp, myHandler, pData, <data size>,
MOL_DELAYED_HANDLER, NULL);
Language Extensions for the
Mobile Object Layer
• What would be nice:
– Declaration/creation
MobileObject<Foo>* pObject = new MobileObject<Foo>;
– Method invocation
pObject->method(pData);
Language Extensions for the
Mobile Object Layer
The goals of the project are the following:
1.Design and implement a C++-friendly
interface for the MOL.
• Either template based, or
• Using syntactic extensions.
2.Compare C++ programs written using the
C-style interface with your C++ interface
Computationally Intensive
Mobile Computing
Local
Remote
Should we execute locally or remotely?
Computationally Intensive
Mobile Computing
The goals of the project are the following :1.Develop a simple model for predicting the
performance of local and remote execution.
2.Build a restructuring compiler to generate
programs for local and remote execution.
Computing Reuse Distance
Exactly
• Can we compute reuse distance exactly at
compile time?
Computing Reuse Distance
Exactly
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.
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.
Threaded-C
Project idea:
Restructuring compiler
to parallelize loops to
Threaded-C