%%% $Id: intro.tex,v 1.5 2005/12/09 12:39:19 gokhale Exp $

\section{Introduction}
\label{intro}
Society is increasingly reliant on a wide array of services (e.g.,
electric power grid, mobile communications, health care,
entertainment) provided by distributed networked systems.  Rapid
advances in networking and hardware technologies, and increased
competition, is requiring service providers to rapidly introduce newer
services to the market.  Service providers, however, now have to deal
with two major forces.  On the one hand they must reduce the {\em time to
  market} while on the other hand they must ensure that the services
continue to provide high performance and dependability.  

One predominant feature of these networked systems is their 
event-driven capability requiring efficient demultiplexing, dispatching and
servicing of the events~\cite{Liu:00}.  The event-driven style
constitutes a provider/\-listener model~\cite{garlan93}, where the
application listens for service requests or ``events'' and  provides
the necessary services in response to these requests or events.
Event-driven systems provide many advantages, the most prominent
advantage being evolvability, which is enabled by the separation of
event demultiplexing and dispatching from event handling.  Although
the handling of events is specific to the service itself, the event
demultiplexing and dispatching functionality is more or less uniform
across all the services that follow the event-driven style, and can be
codified into a reusable building block or a
pattern~\cite{Vlissides:94}.  The {\em Reactor}
pattern~\cite{Schmidt:00a} embodies the demultiplexing and dispatching
capabilities that could be reused to facilitate the development of
event-driven applications.   

There are numerous additional commonly occurring patterns in such
services that address issues, such as concurrency, connection
management, prioritized service and data (de)marshaling.  Standards
middleware, such as CORBA, J2EE and .NET, provides the building blocks
that address these issues.  Middleware building blocks thus provide
the means to rapidly compose, configure, assemble and deploy the
services that service providers want to rapidly bring to market.    

Service providers are, however, now required to ascertain whether the
choice of building blocks, and their configurations and compositions
will provide the required levels of performance and dependability.
This analysis must be performed in the early phases of the system's
life cycle~\cite{bbook-new} (i.e., at design time).
\iffalse
% Swapna, I am commenting this for now - ASG
Moreover, pure performance analysis, 
which does not consider application failures leads 
to optimistic performance estimates. Thus, it is important to consider
application failures during performance analysis in order to
provide realistic ``performability'' estimates~\cite{smith90}. 
\fi
Design-time performance analysis is almost invariably based on a model
that represents application behavior.  For example, in order to enable
model-based performance analysis of event-driven applications, it is
necessary to build a model of the underlying event demultiplexing
framework that is ubiquitous in such applications. In the past,
design-time performance analysis has been conducted for a specific
application. In some cases, analysis methodology for generic
architecture styles that are applicable at the level of
the application architecture have been developed~\cite{williams02}.

% Swapna, we need a sentence or two here saying what previous
% approaches have done i.e., how models have been built to address
% specific artifacts and mostly dealing with functional
% characteristics but not the non-functional stuff. Plus they did not
% consider systems that are composed and configured
%%%%%%%%%%%% TEXT GOES HERE %%%%%%%%%

% Here I show how our work has progressed - ASG
Our previous work~\cite{Gokhale_Globecom05} described our early work
on applying analytical methods for design-time performance analysis of
event demultiplexing in network services, such as virtual private
networks.  This paper enhances our previous work describing an
approach to conducting design-time performance analysis of systems
composed, configured, assembled and deployed from patterns-based
middleware building blocks.  We describe the manual process in
developing a Stochastic Reward Net (SRN)~\cite{rel-srn} analytical
performance model for patterns-based building blocks.  The manual
development process, however, becomes infeasible and cannot scale
since the middleware building blocks provide numerous configuration
parameters that affect their behavior.  This problem is further
complicated when such building blocks are composed to form larger
systems.\footnote{Other kinds of performance analysis, such as
  simulations or empirical benchmarking will exhibit similar
  challenges.}  To address these concerns we describe a framework
comprising model-driven generative tools~\cite{Janos:97,MDA:01}, which
enables the automatic synthesis of scalable SRN performance models,
simulations and empirical benchmarks for services that are modeled as
a composition of patterns-based middleware building blocks. 

This paper is organized as follows: 
Section~\ref{sec:reactor_perf} discusses the process of building a
performance model of the reactor pattern using the SRN modeling
paradigm;  Section~\ref{sec:mdd} describes how the performance
analysis process can be scaled and automated using a model-driven
generative framework; Section~\ref{sec:eval_perf} illustrates the use of
our MDD framework for performance analysis of a application on mobile
devices; Section~\ref{sec:relwork} discusses our work comparing it to
related work; and finally Section~\ref{sec:conclusions} provides
concluding remarks outlining the lessons learned from this study, as
well as directions for future research. 
