% $Id: related.tex 16889 2009-02-21 03:51:46Z gokhale $
\section{Related Work}
\label{sec:related}

Since the work presented in this paper results in performance
optimizations to the underlying middleware thereby improving the quality
of the DRE system software architecture, we compare our work with
synergistic works.  Moreover, since our research is applicable at
design-time, we focus primarily on design- and deployment-time
techniques to compare our work against.

Design-time approaches to component middleware optimization include
eliminating the dynamic loading of component implementation shared
libraries and establishing connections between components done at
runtime, as described in the static configuration of
CIAO~\cite{Subramonian:04c}.  Our approach is different since it uses
model transformations of configurations at design-time.
Our approach is thus not restricted to optimizing just the
inter-connections between components.  Moreover, the static
configuration approach can be applied in combination to our approach.

Another approach to optimizing the middleware at design/development-time
employs context-specific middleware specializations for product-line
architectures~\cite{Schmidt:05h}.  This work is based on utilizing
application-, middleware- and platform-level properties that do not vary
during the normal application execution in order to reduce the excessive
overhead caused by the generality of middleware platforms.  

Some work has also been done in the area of Aspect-Oriented Programming
(AOP) techniques that rely essentially on automatically deriving subsets
of middleware based on the use-case requirements~\cite{Hunleth:02}, and
modifying applications to bypass middleware layers using aspect-oriented
extensions to CORBA Interface Definition Language
(IDL)~\cite{ByPassIDL:07}.  In addition, middleware has been synthesized
in a  ``just-in-time'' fashion by integrating source code analysis, and
inferring  features and synthesizing
implementations~\cite{ArnoJacobsenJitM:05}.    

Contrary to the above approaches, our model transformation-based
technique relies only on the specified (1) QoS requirements
specification and (2) the initial deployment plan, in order to optimize
the QoS policies.  Our approach does not necessitate any modifications
to the application, \emph{i.e.}, the application developer need not
design his/her application tuned for a specific deployment scenario.  As
our results in Section~\ref{sec:discussion} have indicated, our approach
can be used in a complementary fashion to any of the
design/development-time approaches discussed above, since there exist
several opportunities for QoS optimization at various stages in
application development.  

Deployment-time optimizations research includes
BluePencil~\cite{BluePencil:06}, which is a framework for
deployment-time optimization of web services.  BluePencil focuses on
optimizing the client-server binding selection using a set of rules
stored in a policy repository and rewriting the application code to use
the optimized binding.  While conceptually similar, our approach differs
from BluePencil because it uses models of application structure and
application deployment to serve as the basis for the optimization
infrastructure.

BluePencil uses techniques such as \emph{configuration discovery} that
extract deployment information from configuration files present in
individual component packages.  By operating at the level of individual
client-server combinations, the QoS optimizations achieved in our
transformation-based approach are non-trivial to perform in BluePencil.
BluePencil also relies on modification to the application source code to
rewrite the application code, while our approach is non-intrusive and
does not require application source code modifications, and it only
relies on the specified application policies and deployment plans.

Research on approaches to optimizing middleware at runtime has focused
on choosing optimal component implementations from a set of available
alternatives based on the current execution
context~\cite{AutoPerfJ2EE:04}.  QuO~\cite{Quo:97} is a dynamic QoS
framework that allows dynamic adaptation of desired behavior specified
in \emph{contracts}, selected using proxy objects called
\emph{delegates} with inputs from runtime monitoring of resources by
\emph{system condition} objects.  QuO has been integrated into component
middleware technologies, such as LwCCM.

Other aspects of runtime optimization of middleware include
domain-specific middleware scheduling optimizations for DRE
systems~\cite{Schmidt:01s}, using feedback control theory to affect
server resource allocation in Internet servers~\cite{zhang:02} as well
as to perform real-time scheduling in Real-time CORBA
middleware~\cite{Lu-FCS:02}.  Our work is targeted at
optimizing the middleware resources required to host composition of
components in the presence of a large number of components, whereas,
the main focus of these related efforts is to either build the
middleware to satisfy certain performance guarantees, or effect
adaptations via the middleware depending upon changing conditions at
runtime.  

\iffalse
Runtime approaches to application-specific optimizations have focused on
data replication for edge services, \emph{i.e.}, replicating servers at
geographically distributed sites~\cite{Gao:03}.  Significant performance
improvements in the latency and availability has been achieved by
relaxing the consistency of data that is replicated at the edge servers
using application-specific semantics.  Other research on optimizing web
services has focused on utilizing reflective techniques encapsulated in
the request metadata~\cite{Mukhi:04} for dynamic negotiation of best
communication mechanisms between any requester and provider of a
service.  Other research~\cite{Gurdip:05} on dynamic optimization
approaches include improving algorithms for event ordering within
component middleware by making use of application context information
available in models.

The approaches outlined above optimize the middleware/\-on-the-wire
protocol using knowledge of the computations performed by the
application.  Our approach makes use of the application deployment
information on each node of the target domain and is thus focused on
optimizing the execution of the components at each end-system as opposed
to optimizing the on-the-wire protocol. 
\fi

