Guidelines
Proposals
Final Report
Facilities
Suggestions
Ideas
The second step, typically after the class midterm (which will be in the first week of October), is having produced much of the software necessary, and having debugged it.
The third step MUST include not only software testing but also performance evaluation, on the platforms you have chosen. Such evaluations may also be of a theoretical nature, if you chose to develop a novel algorithm, for instance, but your project must include experimental research in addition to algorithm development.
The final deliverable not only includes the actual software but also
a report, which is outlined next.
* Enforcement of real-time constraints possible through
ability to have privileges akin to super-user.
* Ability to run on dedicated single (4 way shared
memory multiprocessor) or multiple machines, networked via switched 100MB
ethernet (the high performance myrinet network is also available on those
machines).
* Ability to use experimental kernel-level real-time
facilities including the DWCS scheduling used in first project.
* Contact Neil Bright (ncb@cc), Christian
Poellabauer (chris@cc), or Ivan Ganev (ganev@cc) for details on hardware/software
setup.
2. High end cluster machines, one comprised of 40 dual Pentium IIs, the other comprised of 16 8-way Pentium IIIs. Contact Matt Wolf (mwolf@cc) for more information and machine access.
3. A large, shared memory multiprocessor (an SGI Origin machine). Contact Matt Wolf (mwolf@cc) for more information.
4. 'New' boxes, including (1) some Itanium-based machines from Dell, (2) a brand new high end Pentium IV Xeon box, also from Dell and (3) brand new Sun 30s, All of these machines may be used with exclusive access for testing or benchmarking purposes.
5. A Linux 'hack cluster': 6 machines on which you can get superuser privileges and do kernel-level development. Contact Neil Bright (ncb@cc) for access and information.
6. Laptops (only one available), multiple Compaq iPAQ handheld computers using wireless links, and a brand new xscale-based machine:
* Running Linux (multiple configurations of Linux
are available and may be installed there). Both Java and C/C++ programming
are possible.
* Ability to use dedicated base station and/or use
campus wireless network, via 11MB WaveLAN wireless ethernet cards.
* Ability to experiment with new 802.11a standard
(30+MB wireless ethernet).
* Ability to attach and use cameras with the laptops
and in the near future, with the ipaqs.
* Contact Matt Wolf or Yuan Chen (yuanchen@cc)
for additional information.
7. Embedded communication subsystems, using Intel's IXP1200 StrongArm-based router boards:
* Given somewhat scarce resources (a donation of
additional boards and machines from which to use them from Intel is on
its way), two project teams of 2 people each can use Intel IXP1200 routers,
running Linux, full cross-development and debugging from Linux machines,
full simulation environment runs on Windows machines.
* Contact Ada Gavrilovska (ada@cc), Ivan Ganev,
or Weidong Shi (shiw@cc) for more information on IXPs.
8. Large-scale visualization media, including an Immersadesk and a video wall. (contact Matt Wolf for more information).
1. Projects addressing operating system kernels:
* Use Netfilter to mark up packets according to complex rules and then
write a kernel extension executing in a driver to act on the markings in
an applications-specific way, such as redirecting them through a specific
type
of network link, or rewriting parts of the header. Contact Ivan Ganev
for more information (ganev@cc).
* Implement related monitoring functionality on IXP boards. Contact ada@cc for more information.
* Work with a novel socket interface, termed QSockets. This existing
QoS-enriched socket API needs to be tested with several different packet
scheduling policies and a network manager has to be implemented as kernel-loadable
module which admits
and manages the network resources assigned to applications (requires
Linux kernel programming). Contact habbasi@cc for more information.
* Implement some kernel extensions on two or more machines that communicate
via a new inter-kernel publish/subscribe mechanism developed recently by
Christian Poellabauer (chris@cc). In addition, you could use Ivan Ganev's
'safe' kernel extensions to implement functionality like 'remote DProbes',
ie, they extend the kernel at certain places with specialized code for
debugging or monitoring purposes, but that can be done 'remotely', ie.,
the specialized code is not only added to the local machine but to each
kernel of a whole cluster and debugging/monitoring information is returned
to the initiating machine via kecho events. Alternatively and
perhaps simpler, `remotely' change system call behavior (like Calton
Pu's work on code specialization) in the same manner (i.e., using kecho
and dynamic binary code generation for a whole cluster). Contact Christian
Poellabauer (chris@cc) for more information.
* Make the operating system kernel into a 'function cache' for applications.
Specifically, construct a simple RPC mechanism by using kecho to remotely
call functions, but then have the machine that offers those functions push
frequently invoked functions via Ivan Ganev's code generation
into the kernel, such that those functions are invoked directly in
the kernel (somewhat like the concept of active messages). Less frequently
used
functions can be replaced by more frequently functions, effectively
making the kernel into a 'functions-cache'. Contact Christian Poellabauer
(chris@cc) for more information.
2. Projects at the application level:
* Build an efficient version of the LDAP directory service. Specifically,
use an existing, open source implementation of LDAP to create
better directory services for distributed systems. The idea is to ENHANCE
LDAP FUNCTIONALITY with `activity', using as a basis a simple, proactive
directory service (not implemented with LDAP) created by our group in earlier
work. Contact Patrick Widener (pmw@cc) for more detail.
* Experiment/work with Microsoft's new .net infrastructure. Specifically,
first use its SOAP remote invocation functionality, then
enhance it to improve SOAP performance. Enhancements are possible along
two directions: 1) work with other students (contact bala@cc) to improve
SOAP's abiliit to transfer parameters, especially larger parameters, and/or
2) add network awareness to SOAP, to permit it to change communication
behavior when network conditions change. Or, explore the same for SOAP
as for the
RMI project listed next.
* Implement 'code' caching: Java Remote Method Invocation (RMI) makes
it easy to build distributed applications and services in a heterogeneous
environment. When the applications are interactive and require low
response
time, efficient implementations of RMI are needed. Object caching allows
objects to be cached at client nodes and invokes them locally when
implementations of RMI are needed. In these case, the overhead associated
with communication can be avoided when there is significant locality
of
access. However, coarse-grained objects may be bound to physical places
as
the result of parts of their code being bound to certain physical resources.
More importantly, large state caching at clients may lead to call
invalidation protocol more frequently and hence causes more overhead.
In
this project, students will explore a fine-grain code migration method
to
optimize RMI calls. Specifically, rather than caching the whole state
of
objects, our approach partitions each method of a server into two parts
and
ship one part to a client and run the part in the client's address
space. We
expect that this approach will improve RMI response time by distributing
processing across clients and server and reducing unnecessary communication
costs between them. You are required to develop a prototype RMI system
which
allows methods to be shipped transparently. Students should report
some
performance results of the approach by comparing the performance of
RMI
application programs using standard RMI and the optimized version.
The new
system will be built on top of the JECho publish/subscribe communication
infrastructure. JECho supports automatic method partitioning and
installation at runtime. Contact Yuan Chen (yuanchen@cc) for more detail.
* Group synchronization for cluster servers: distributed applications
often rely on multiple processing nodes collaborating and synchronously
advancing their application' states. Many protocols have been defined
which
target the problem of reliable group synchronization, consistency across
multiple cooperating nodes, synchronous checkpointing and recovery
mechanism, etc. Optimistic Virtual Synchrony is one such algorithm.
This
project is a multi-phase evaluation of a group synchronization algorithm,
particularly the Optimistic Virtual Synchrony (OVS) algorithm. The
goal of
the project is to implement the algorithm at several different levels,
and
compare and understand the trade-offs encountered at each level. Initially,
you should implement the OVS algorithm at user level, for a cluster-wide
server application. Next, you should move the user level implementation
into
the Linux kernel, and evaluate the performance implications of the
kernel
level implementation. In the second stage of the project, you will
be
experimenting with the programmable network boards, IXP1200s. Particularly,
you will perform comparative performance analysis between the OVS
implementation on the cluster nodes, and the IXP1200 resident StrongArm
processors. You should perform predictive studies with the ixp1200s,
and
make conclusions about the performance implications of moving the
synchronization mechanisms onto the network boards. the performance
implications of moving the synchronization mechanisms onto the network
boards. For more detail on the project, questions, documentation, and
reference material, contact Ada Gavrilovska (ada@cc.gatech.edu).
* Implement secured teleconferencing using Access Grid technology: the
Access Grid is the premier medium for interactive, wide area high
performance computing, originally developed by DOE reserachers, but
with
recent substantial company support from IBM. This task involves the
construction of two possible demonstration programs using Access Grid
technologies: (1) 3-way always-on demonstration for creating a virtual
lab
for the GT CERCS center, or (2) the inclusion of wireless devices in
an
Access Grid, using iPAQs and/or laptops. Contact Matt Wolf (mwolf@cc)
for
more information.
* Use a wireless device as a 'smart' pointer: Given large-data displays
like those on video walls, it is hard to users to navigate in such
displays
and inspect data in detail. This project will have you use an iPAQ
device as
a smart pointer into a display, where the ipaq can display details
of the
data being viewed in its current pointer location. Thus, the ipaq is
used to
navigate and retreive a "personal viewpoint" from within the larger
visualization. The main display (in this case our video well or immersadesk)
would have notation points for where each of the viewers were located,
and
viewers could push & pull information from one another. An extension
of this
project concerns program steering via the ipaq. Contact Matt Wolf (mwolf@cc)
for more information. While this project has been ongoing for a while,
there
are several interesting things be done, including 1) create a flexible
graphics pipeline that can be 'split' across clients and servers in
different ways, possibly including work on graphics compression algorithms,
2) add other clients and services to the application, thereby providing
additional viewpoints to science end users, or 3) experiment with location-
and orientation-awareness for the handheld devices being used.
* Benchmark the newest and niftiest machines out there. Use both
standard benchmarks (including web server benchmarks) and realistic
application programs (the latter not to be developed by you) to evaluate
the newest machines made by manufacturers like Intel/Dell and SUN
Microsystems. Contact Matt Wolf (mwolf@cc) for more information.
The following constitute project ideas that you need to work out in
more
detail, including the submission of a detailed project proposal, as
specified in the Special Project Guidelines. Projects that we know
to be
definitely doable within the time constraints imposed by this class
are
highlighed. Other project suggestions must be defined in more detail,
which
is part of your task when refining the project with your proposal.
Projects addressing operating system kernels:
* M-Socks: Implementation of a network monitor (in a kernel module)
and
extension of the socket API to support the programming of this module
and
the retrieval of monitoring information (requires Linux kernel programming).
Contact Christian Poellabauer (chris@cc) for more information.
* Modification of an exisiting virtual environment or multiplayer game
(e.g., Quake), such that it uses a group communication tool (ECho/KECho)
developed by our group. This modified application will then be used
as a
basis for experiments (e.g., filtering of events). One such game (Doom)
already uses this tool, however, we wish to use a more recent application.
Contact Christian Poellabauer (chris@cc) for more information.
* Construct analysis functions that evaluate communication performance
at runtime, then export such information to elsewhere in the kernel
or to
user level. Use such information to applications at runtime. Utilize
some of
your previous experiences with libpcap. Contact Christian Poellabauer
for
more detail (chris@cc).
* Using a reliable UDP protocol and experiment with the effects of
different reliability methods for wireless communications. Goal is
to
develop adaptive protocols to improve performance or other quality
of
service metrics for wireless communications. Contact (chris@cc) for
more
information. This work could take place at user- and/or at kernel-level.
* Experiment with kernel-level task scheduling, including replacing
the
current Linux task scheduler and/or improving it. Contact Ivan Ganev
(ganev@cc) for more information.
* Port efficient binary communication software to the new XScale
architecture. This project includes runtime binary code generation
for
xscale processors. Contact Greg Eisenhauer (eisen@cc) for more information.
Projects that develop certain applications:
* Stub generation: develop compiler support for alternative
layout/organization/marshaling and unmarshaling of binary data (based
on
XML-level data descriptions), thus affecting performance and predictability
of data movement via communication links. Contact Patrick Widener (pmw@cc)
for more information.
* Build and extend a web server, using Apache as a starting point.
This
could also involve using and/or extending the Linux kernel http stack
(khttp). Alternatively, develop novel web applications, such as VOIP
(Voice
over IP) or others. Contact chris@cc for more information.
* Work with publish/subscribe software written in Java or written with
C
on wireless or embedded Linux systems. Contact eisen@cc for more information
on the C version, Dong Zhou (zhou@cc) for more information on the Java
version. Add specific functionality addressing quality of service,
including
(1) online scheduling for events (contact chris@cc for more information),
or
(2) support for event routing and re-routing in self-organizing networks
or
for scalability for Internet-wide systems (contact yuanchen@cc for
more
information), or (3) develop support for automatic replication of
communications for improved reliability (contact ada@cc for more
information).
* Develop dynamic monitoring support to diagnose communication or
platform performance for embedded/wireless systems, based on an existing
cluster-level monitoring facility. Kernel ports of selected functionality
are possible, as well. Contact mwolf@cc for more information.
* Develop sample distributed applications. Most interesting are: (1)
ubiquitous or embedded applications that involve both real-time sensing
and
reactions to sensor data and use wearable or portable machines, (2)
experimentation with adaptive applications, including video transfers
(raw
video or MPEG/SPEG encoded) and evaluating their performance (including
power consumption) on wireless and embeddded devices, (3) innovative
distributed applications including video games, remote robot control,
immersive systems, using real-time feeds (e.g., gotten from Atlanta's
traffic web pages or from sports actions), or using immersive equipment
available in CoC (available equipment includes 3D headsets, video wall,
Immersadesk) and large data sets (e.g., earth observational data).
Propose
to instructors and also contact mwolf@cc for more information.