This is a list of project ideas suggested by various people at Berkeley, LBNL, and NERSC (roughly in the order in which they were suggested). For further information, contact the person listed:
From
Professor Demmel
in the Computer Science department:
New Parallel eigensolvers for ScaLAPACK
Using existing parallel linear algebra code in some application
Port some parallel linear algebra to NOW:
Xiaoye Li's parallel sparse LU code for SMPs
Port any ScaLAPACK code to CLUMP
Serious 3DFFT for NOW, or CLUMPS
LU on the NOW cluster and hopefully getting the NOW onto the list of the world's fastest 100 machines (for solving this very specific problem).
From the
NERSC/LBNL Visualization Group
:
Particle flow (streamlines): Compute the flow of many particles given velocity vectors in three dimensions (possibly time varying).
Radiosity: Compute the image which results when many, varied light sources illuminate relecting and absorbing objects.
Isosurface: Compute the surface where scalar data in three dimensions attains a given value.
Volume rendering: Compute the image which results when scalar data in three dimensions are drawn with given colors and translucency.
From
Jasmina Vujic
and her PhD student Steve Slater (
slater@nuc
) in the Nuclear Engineering department. (These are ideas in the context of "Computer modeling for radiation diagnostic and cancer therapy" and "Development of multiprocessor multiassembly neutron transport theory code".):
A new ray tracing for true 3d ray tracing in hopefully a reasonable amount of time.
Automatic division of work from one or multiple input files onto N processors. Load balancing would be a plus.
From the
Digital Libraries
group in the Computer Science department:
Document preparation (
joyceg@cs
)
Disambiguation: categorization training and categorization prior to collecting (
isaacc@cs
)
Web categorization (
isaacc@cs
)
Colored dot finding (
carson@cs
,
sjb@eecs
)
Image feature extraction and categorization (
carson@cs
,
sjb@eecs
)
USGS DOG processing (
fccheong@cs
)
A link to
project suggestions
from Horst Simon (who's joint-teaching this class with Professor Culler).
Suggested by
Victor Markowitz
of the
Object-Protocol Method (OPM) group
:
possibly study two databases, study a trace of requests/queries that they have, and propose how best to build a framework that makes the databases look integrated. The proposal would have to include provisions for scaling up.
From
Eric Brewer
of the CS department:
Categorizing the web: figure out how to implement a distributed SVD on a very large, sparse matrix.
From the
CMB Astrophysics Research Program
(
George Smoot
and Andrew Jaffe (
jaffe@physics
) talked in class on Friday, March 7th) we have these
potential software projects
.
From
Professor Yelick
in the Computer Science department:
Implement a 3DFFT for CLUMPS. Questions that could be considered include:
Is there a better local FFT that can take advantage of the individual SMPs in a CLUMPS?
Implementing oct-trees for Multipol for the NOW. Port the Barnes-Hut code from the Splash benchmark so that it uses the implemented oct-tree.
From
Professor Culler
in the Computer Science department:
Putting together a tool that lets you computer over adaptive meshes changing over time. Questions to answer include:
How do you map grids to processors?
What happens when you decide that you need a finer mesh somewhere, or that you don't need quite so fine a mesh somewhere?
Does the optimal mapping to processors change on a CLUMP?
I/O, checkpointing. Possibilities include:
Is there a way to write out the state of a computation to disk intelligently so that you can resume in the middle? Things to consider:
parity bits?
can you write it out so that it can be read back in for any number of processors? In any layout?
Is there some nice methodology for running out-of-core code?
Performance analysis: analyze some benchmark on a CLUMP. Questions to answer include:
Do different processors in the SMP need to be treated differently? (As Scott Baden claims in
Non-Uniform Partitioning of Finite Difference Methods Running on SMP Clusters
)
Do you (how do you) block for the individual SMP? (Columns per SMP? Blocks per SMP?)