1. Integration of QoS-Enabled Distributed Object Computing Middleware for Developing Next-Generation Distributed Applications
BBN Technologies Washington University
Cambridge, MA St. Louis, MO
Craig Rodrigues, David A. Karr Yamuna Krishnamurthy
Joseph P. Loyall, Richard Schantz Vishal Kachroo
University of California
Irvine, CA
Douglas C. Schmidt
ACM SIGPLAN Workshop on
Optimization of Middleware and Distributed Systems (OM 2001)
June 18, 2001

2. Unmanned Air Vehicle
uav.navair.navy.mil/home.htm

3. Prototype Architecture
Video feed from off-board source (UAV)
Distributor sends video to hosts on ship’s network
Users’ hosts receive video and display it
Users send commands to UAV to control it 1 2 3

4. Why is Adaptation Necessary?
Limited resources
CPU and network bandwidth are shared by many applications, not just video
Some applications are of higher priority than others, so it becomes necessary to adapt in response to scheduling and resource management decisions

5. UAV adaptive tactics ...PBBPBBPBBI I I I NETWORK RESERVATION
IBBPBBPBBPBBPBBPBBIBBPB
NETWORK RESERVATION
Under excessive Network load - Use IntServ/DiffServ to reserve bandwidth
...PBBPBBPBBI
I I I
DATA FILTERING
Excessive network or CPU load - Drop frames
LOAD BALANCING
Excessive CPU load - Move distributor to more lightly loaded host

6. CORBA Audio/Video Service
Why use a Framework?
Quality Objects (QuO)
provides higher level programming model for specifying application-level QoS
CORBA Audio/Video Service
abstracts away network programming concerns such as connection management
ACE QoS API (AQoSA)
uniform API for QoS (RSVP, GQoS)

7. UAV application design
CORBA A/V Streaming Service
+ AQoSA Resource Reservation (IntServ)
CORBA A/V Streaming
Service
Video
Source
Process
Video
DIstributor
Video
Display
Proxy
Video
Display
Reservation requests
Observed throughput
Frame filtering commands
VIDEO DISPLAY HOST 1
QuO
Contract
UAV
Video
File
VIDEO DISPLAY HOST 2
VIDEO DISTRIBUTION
HOST
UAV
SIMULATION
HOST
VIDEO DISPLAY HOST N
Common middleware services
TAO CORBA A/V Service
QuO
AQoSA
TAO Naming Service
Reused Off the Shelf Software
DVDView video player

8. Functionality of the UAV architecture
Video
Source
Process
UAV
SIMULATION
HOST
Video Distributor
VIDEO DISTRIBUTION HOST
Video Display
VIDEO DISPLAY HOST 1
Display Proxy
VIDEO DISPLAY HOST N
Functionality
Read bytes from a file
Convert into frames
Send out pipe
Other inter-twined aspects
Timing: periodic delivery of frames
Base Functionality
Receive frames
Send frames to registered receivers
Other intertwined aspects
Functional:
Frame filtering (i.e., frame dropping)
QoS:
Measuring frame rate
Measuring resource usage and availability (CPU and network)
Adapting to performance degradation (e.g., frame dropping, load balancing)
Real Time:
Time stamping
Sequencing
Display frames on the screen
Removing time stamp
Removing sequencing
Discarding frame if late or out of sequence
VIDEO DISPLAY HOST 2

9. Quality Objects (QuO)
Provides a higher level programming model for specifying application QoS
operating regions specified in QuO Contracts
transitions between regions trigger adaptive behaviors
Support for different middleware architectures
CORBA (Java and C++)
Java RMI

10. Specifying QoS behaviors with QuO
C++ Application Code
behavior Timestamp () {
void distributor::send_frame(ACE_Message_Block *frame)
{ inplaceof METHODCALL {
ACE_Message_Block *timed_msg = add_timestamp(frame);
remoteObj->send_frame(timed_msg); } }
void displayproxy::send_frame(ACE_Message_Block *frame)
{extern long last_time_processed;
inplaceof METHODCALL {
ACE_Message_Block *timed_msg = remove_timestamp(frame, tsp);
if (tsp >= last_time_processed) { // is this a late frame
remoteObj->send_frame(timed_msg);
last_time_processed = tsp;
// else drop frame, a more recent frame has already been delivered };
class Sender {
public:
/// Constructor
Sender (void);
int init (int argc, char **argv, CORBA::Environment&);
/// Method to initialize the various data components.
/// Method to pace and send data from a file.
int pace_data (CORBA::Environment &);
/// Accessor to the connection manager.
/// Amount of debugging info to print out: 0 = none, 10 = lots
Connection_Manager &connection_manager (void);
int debug_level_;
private:
/// Method to parse the command line arguments.
}; ...
...
class Distributor
Distributor (void);
/// Destructor.
~Distributor (void);
/// Initialize data components.
/// Parse args.
int init (int argc, char **argv, CORBA::Environment &);
int parse_args (int argc, char **argv);
// Flag to know when we are done.
int done (void) const;
/// Accessor to connection manager.
void done (int);
/// Amount of debugging output to print out; 0 = none, 10 = lots
/// Connection manager.
protected:
class Sender {
public:
/// Constructor
Sender (void);
int init (int argc, char **argv, CORBA::Environment&);
/// Method to initialize the various data components.
/// Method to pace and send data from a file.
int pace_data (CORBA::Environment &);
/// Accessor to the connection manager.
/// Amount of debugging info to print out: 0 = none, 10 = lots
Connection_Manager &connection_manager (void);
int debug_level_;
private:
/// Method to parse the command line arguments.
}; ...
...
class Distributor
Distributor (void);
/// Destructor.
~Distributor (void);
/// Initialize data components.
/// Parse args.
int init (int argc, char **argv, CORBA::Environment &);
int parse_args (int argc, char **argv);
// Flag to know when we are done.
int done (void) const;
/// Accessor to connection manager.
void done (int);
/// Amount of debugging output to print out; 0 = none, 10 = lots
/// Connection manager.
protected:
class Sender {
public:
/// Constructor
Sender (void);
int init (int argc, char **argv, CORBA::Environment&);
/// Method to initialize the various data components.
/// Method to pace and send data from a file.
int pace_data (CORBA::Environment &);
/// Accessor to the connection manager.
/// Amount of debugging info to print out: 0 = none, 10 = lots
Connection_Manager &connection_manager (void);
int debug_level_;
private:
/// Method to parse the command line arguments.
}; ...
...
class Distributor
Distributor (void);
/// Destructor.
~Distributor (void);
/// Initialize data components.
/// Parse args.
int init (int argc, char **argv, CORBA::Environment &);
int parse_args (int argc, char **argv);
// Flag to know when we are done.
int done (void) const;
/// Accessor to connection manager.
void done (int);
/// Amount of debugging output to print out; 0 = none, 10 = lots
/// Connection manager.
protected:
behavior Sequence () {
int sequence_number = 1;
void distributor::send_frame(ACE_Message_Block *frame)
{ inplaceof METHODCALL {
// insert sequence number
ACE_Message_Block *seq_msg =
add_sequence_number(frame, sequence_number);
remoteObj->send_frame(seq_msg);
seq_number++; } } };
behavior Filter () {
void distributor::send_frame(ACE_Message_Block *frame)
{ inplaceof METHODCALL {
// examine contract and drop B or P frames if necessary
... } };
Video
Source
Process
Video
Distributor
Process
Filter?
Insert
Seq. No.
Display
Proxy
Process
Video
Display
Process
Periodic
Delivery
Insert
Timestamp
Remove
Timestamp
Remove
Seq. No.
Filter?
Insert
Seq. No.
UAV
SIMULATION
HOST
VIDEO DISPLAY HOST 1
VIDEO DISTRIBUTION HOST
VIDEO DISPLAY HOST 2
VIDEO DISPLAY HOST N

11. CORBA Audio/Video Streaming Service
Goals of OMG CORBA A/V Service Specification
Define standard mechanisms for:
Stream Establishment
Stream Control
Multiple Flows
Multiple Protocols
QoS
Goals of TAO A/V Streaming Service Project
Implement OMG CORBA A/V Service Specification using TAO

12. CORBA A/V Service Overview
Stream
EndPoint
(Sink)
Stream Interface
Control Object
Stream Interface
Control Object
Stream
EndPoint
(Source)
Control
and
Management
Objects
Stream
Adaptor
POA
POA
Stream
Adaptor
ORB
Multimedia Stream

13. CORBA A/V Service Overview
StreamCtrl
controlling the stream
MMDevice
interface for logical or physical device
StreamEndPoint
network specific aspects of a stream
Vdev
properties of the stream

14. QoS Enabled TAO A/V Service
TAO AV QoS Framework
AQoSA
QoS Mapping
QoS Monitoring
QoS Adaptation
ACE QoS API (AQoSA)
RAPI
GQoS

15. AQoSA API Binds flows to reservations in a uniform and portable way
Encapsulates application’s notion of the underlying network QoS
Separates QoS properties of its sessions from low-level socket data transfer aspects
Allows the application to specify and request QoS. Be notified if the QoS was not available
Updates itself based on QoS notifications
Portably wraps the QoS parameters
Implementation targets (RSVP) Resource reSerVation Protocol
RAPI & GQoS

16. AQoSA Architecture

17. Connection Establishment
bind_devs (aMMDevice, bMMDevice)
StreamCtrl
create_B
create_A
(with QoS)
A_Endpoint, A_VDev
B_Endpoint, B_VDev
connect
QoS Monitor
QoS Mapper
aMMDevice
bMMDevice
register session
app qos
qos events
network qos
and callback
A_Endpoint
AQoSA
B_Endpoint
create
session
request_connection
reserve
path
bVDev
aVDev
configure

18. X X Change in QoS AQoSA QoS Monitor adapt AV_Adaptor adapt Adaptor
configure
change
Shaping
Filter
Selection
Filter
AV_Adaptor
qos events
modify X X
AQoSA

19. Integrating TAO A/V in the UAV Application
More flexible than ad-hoc socket code
Facilitated additional features:
Multiple Viewers
Multiple receivers
Movable distributors
Network level QoS (with AQoSA)
Host name and port info
Migration of the processes across different hosts was cumbersome
Poor scalability and flow management
Not flexible to design changes and addition of components.
Video
Source
Process
Video Distributor Process
Display Proxy Process
Video Display Process
Instrumentation
A/V Stream
Adhoc TCP Connection
Video
Forwarding
Code
Adhoc TCP Connection
A/V Stream + AQoSA
Video
Forwarding
Code
Video
Display
Code
Video
Forwarding
Code
CPU load
Throughput
Output Rate Control
Queue Size
Bandwidth
Output Rate Control
Throughput
Contract
CPU load
UAV
Video
File
Contract
QuO Adaptive Control Process
QuO Adaptive Control Process
VIDEO DISTRIBUTION HOST
VIDEO DISPLAY HOST

20. Flexible Configuration
Distributor Switching
Sender Switching
Multiple Receivers
Multiple Distributors
Sender Restarting
Sender X
Distributor X X
Receiver
Sender X
Distributor X
Receiver-1
Distributor-1
Receiver-2

21. Further References and Obtaining Software
information about QuO framework
to obtain QuO, send to
source code for TAO ORB, CORBA A/V service, and AQoSA
UAV application uses TAO or higher (TAO 1.2 major release is imminent)
further information can be obtained via from
Contact information:
Craig Rodrigues,
Yamuna Krishnamurthy,