Transcript CSE Poster Workshop 2002 Presentation Slides

Run-Time Support for Adaptive
Communication Services
By: SeyedMasoud Sadjadi
Advisor: Dr. Philip K. McKinley
Computer Science and Engineering
Michigan State University
This work was supported in part by the U.S. Office of Naval Research under
Grant No. N00014-01-1-0744, and in part by National Science Foundation grants
CDA-9617310, NCR-9706285, CCR-9912407, EIA-0000433, and EIA-0130724.
• Motivation:
– Wireless networks are improving rapidly.
– Mobile computers are gaining more popularity.
– Lots of Software is being developed for this new
infrastructure.
• Problem?
– Dynamic changes in wireless networks.
– Heterogeneity of mobile devices.
• Standard solution:
– Developing adaptive application.
• Problems with adaptive software?
– Adaptive code is scattered all over the application.
– Development, deployment, and maintenance are
difficult.
• Our solution:
– Using Adaptive Java (developed by E. Kasten) to
develop adaptive applications.
• Case Study:
• Audio Multicasting Application (AMA)
• A traditional real-time distributed application that
multicasts a live audio stream over a wired network.
• Motivation:
• Using AMA over a wireless network.
• Problem?
• Wireless network dynamically changes.
• Standard solution:
• Writing an adaptive AMA that uses FEC.
• Problem with adaptive AMA?
• Adaptive code is scattered all over the application.
• Development, deployment, and maintenance are
difficult.
• Our solution:
• Using Adaptive Java to develop a “metamorphic”
socket (or metasocket) that makes AMA adaptive.
• Adaptive code is not tangled to the application code.
Error Control in Wireless
Networks
XX
XX
XX
XX
Wireless Network
Java MulticastSocket
MetaSocket
Adaptive Code
(the cross-cutting concern)
is scattered all over the
application
code
Adaptive Code is
factorized in one component to
better support the development
of evolutionary software
We decided to factorize all of the adaptive code needed to adapt AMA to the
dynamic changes of wireless networks and put them in a “metamorphic”
component named MetaMulticastSocket (MetaSocket in brief). MetaSocket
“absorb”s and “metafy”s the original Java MulticastSocket.You can follow the
steps for building this component in Adaptive Java in the next slides.
Java MulticastSocket
First we extended the original Java MulticastSocket to
support a filter pipeline. This way we could add, remove,
or modify different filters. In this study we just used FEC
Filters, but it can work with other filters.
Then we “absorb”ed MulticastSocketSender using “absorb”
construct in Adaptive Java to create a component from this
Java class. We defined all the invocations that this
component support to provide service to other components.
In this step we “metafy”ed this new component, MulticastSocketSenderComponent using “metafy” construct in Adaptive Java and
defined “refraction”s and “transmutation”s. Refraction methods can
only read the status of a component. Transmutation methods, in
contrast, can only write to the component.
Now that MetaSocket is developed, we need a component that knows
about our specific application (AMA) and customizes MetaSockets
dynamically. We call this component a “Decision Maker”. A decision
maker gets the state of other components using their refraction methods
and adapt them using their transmutation methods.
This is how the whole Microphone application works.
Data loss in 35% Signal Strength
70
60
FEC
inserted
50
40
k=4 n=8
FEC
removed
k=4 n=10
k=4 n=12
k=4 n=20
30
k=4 n=40
20
10
packets grouped in 200 packets
57
53
49
45
41
37
33
29
25
21
17
13
9
5
0
1
Packet loss in groups of 200 packets
80
• Conclusion:
– Developing MetaSocket in Adaptive Java
demonstrated that we can write adaptive
application so that the adaptive code is
separated from the application code.
– Developing, deploying, and maintaining such
applications is much easier.
• Future Work:
– MetaSocket is just one application written in
Adaptive Java. Further investigation on other
adaptive applications showed that Adaptive
Java should be extended.
– Some of the design decision made while
developing Adaptive Java makes its use
limited.