\documentclass[10pt,epsf]{seminar}

\usepackage{fancybox}
\usepackage{epsfig}
\usepackage{moreverb}

\newcommand{\hilite}[1]{\ovalbox{#1}}
\newcommand{\lolite}[1]{{\scriptsize #1}}

\newcommand {\dTAO}{\emph{dynamicTAO}}

%\twoup{}

%\portraitonly
%\landscapeonly

\def\printlandscape{\special{landscape}}    % Works with dvips.
  
\newpagestyle{dgn}{%
  {\em Automatic Configuration of Component-Based Distributed Systems} \hfil \thepage%
}{}

\newcommand{\heading}[1]{%
  \begin{center}
    \large\bf\sl
    \shadowbox{#1}%
  \end{center}
  \vspace{1ex minus 1ex}
  \large
}

%\def\stlist#1{\sTlist#1}
%\def\sTlist#1,#2,#3{%
%  \fmath{#1{\,\stackrel{\scriptscriptstyle #2}{\mapsto}\,}#3}%
%}

%\def\emspc{\vspace{1em minus 1ex}}
%\def\temspc{\vspace{2em minus 1ex}}

\def\leadsto{$\;\Rightarrow\;$\ }

\pagestyle{dgn}
\slideframe{Oval}

\title{Automatic Configuration of Component-Based Distributed Systems}
\author{Fabio Kon \\ \\ Advisor: Prof. Roy H. Campbell \\ \\ 
Department of Computer Science \\
University of Illinois at Urbana-Champaign}

\date{December 16, 1998}

\begin{document}


\raggedright
\maketitle


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\begin{slide}
\heading{Overview}
\begin{enumerate}
\item \hilite{Introduction} %%%%%%%%%%%%%
\item The Problem
\item The Proposed Solution
\item Completed Work
\item Related Work
\item Proposed Research Plan
\item Conclusion
\end{enumerate}
\end{slide}



%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\begin{slide}
\heading{Introduction} %problem, solution, work, experiments

\begin{itemize}
\item Increase in the quantity and complexity of software that needs to be produced.
\item Component Technology
\begin{itemize}
\item JavaBeans, ActiveX Controls, OMG CCM, OpenDoc.
\item Unit of packaging, distribution, and deployment.
\end{itemize}
\item Applications are deployed in different kinds of dynamic environments.
\item Mobile applications travel across different environments.
\end{itemize}

\end{slide}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%\begin{slide}
%\heading{Rapidly Changing Dynamic Environments}
%\begin{itemize}
%\item Different kinds of change:
%\begin{enumerate}
%\item every second: CPU, memory, network
%\item every day, week: system libraries, network services, OS kernels, etc.
%\end{enumerate}
%\item Applications are deployed in different kinds of environments.
%\item Mobile applications travel across different environments.
%\end{itemize}
%\end{slide}



%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\begin{slide}
\heading{Existing Systems}
\begin{itemize}
\item Lack support for representing dependencies among components.
\item Difficult to implement:
\begin{itemize}
\item Fault-tolerance
\item Flexible system architectures
\item Automatic adaptation/configuration
\end{itemize}

\item Component-based applications become unreliable, non-robust.
\end{itemize}
\end{slide}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\begin{slide}
\heading{Thesis Contents}
\begin{itemize}
\item This thesis will present
\vspace{5mm}
\begin{enumerate}
\item A model for reifying inter-component dependence.
\vspace{5mm}
\item A software framework implementing the model.
\vspace{5mm}
\item Experiments deploying the framework in real applications to support
automatic configuration.
\end{enumerate}
\end{itemize}

\end{slide}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\begin{slide}
\heading{Overview}
\begin{enumerate}
\item \lolite{Introduction} 
\item \hilite{The Problem} %%%%%%%%%%%%%%%
\item \lolite{The Proposed Solution}
\item \lolite{Completed Work}
\item \lolite{Related Work}
\item \lolite{Proposed Research Plan}
\item \lolite{Conclusion}
\end{enumerate}
\end{slide}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\begin{slide}
\heading{The Problem}

\begin{itemize}
\item \emph{architectural-awareness}: the capacity of a system to maintain and 
manipulate information about its own architecture and the environment in which it 
is inserted.
\item The lack of \emph{architectural-awareness} is observed in both legacy
and component-based systems.
\item Example of problems it creates:
\begin{enumerate}
\item Fault-tolerance 
\begin{itemize}
\item Failure of a module is not properly handled by the others.
\item Unspecified dependencies that are not resolved.
\end{itemize}

\item Administration
\begin{itemize}
\item Junk libraries left in Windows after applications are uninstalled.
\item Building and installing new packages in a shared UNIX network.
\end{itemize}

\item Operating System Architecture
\begin{itemize}
\item Different instances of the same OS for different users and platforms.
\item Configuration of Microkernel environments.
\end{itemize}
\end{enumerate}
\end{itemize}
\end{slide}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\begin{slide}
\heading{Overview}
\begin{enumerate}
\item \lolite{Introduction} 
\item \lolite{The Problem} 
\item \hilite{The Proposed Solution}%%%%%%
\item \lolite{Completed Work}
\item \lolite{Related Work}
\item \lolite{Proposed Research Plan}
\item \lolite{Conclusion}
\end{enumerate}
\end{slide}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\begin{slide}
\heading{The Proposed Solution}

\begin{itemize}
\item Representing inter-component dependence explicitly.
\item Using this representation to support automatic configuration.
\item Two kinds of dependencies:
\begin{enumerate}
\item \emph{Prerequisites} -- requirements for loading an inert component into the runtime.
\item \emph{Runtime Dependencies} among loaded components in a running system.
\end{enumerate}
\end{itemize}

\end{slide}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\begin{slide}
\heading{Prerequisites}

\begin{itemize}
\item What a component needs to run, e.g.:
\begin{enumerate}
\item The nature of the hardware resources it needs.
\item The capacity of the hardware resources it needs.
\item The software services (i.e. components) it requires.
\end{enumerate}
\item Video client example: (PC w/ MPEG decoding card, 50\% of 200~MHZ CPU, CORBA
video service)
\item Web browser example: (SPARCStation, $\emptyset$ , TCP/IP service \& window
manager \& file service \& JVM).
\item Can be used to implement a WYNIWYG (what you need is what you get) model.
\end{itemize}
\end{slide}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\begin{slide}
\heading{Dynamic Runtime Dependencies}

\begin{itemize}
\item To reify inter-component dependence, the model assigns one
\texttt{ComponentConfigurator} to each relevant component.
\begin{figure}[h]
  \begin{center}
    \leavevmode \epsfig{file=dependencies.eps,width=7.5cm}
  \end{center}
\end{figure}
\end{itemize}

\end{slide}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\begin{slide}
\heading{The \texttt{ComponentConfigurator} abstract class}

{\scriptsize
\begin{center}
\begin{verbatim}
class ComponentConfigurator {
public:
 virtual ComponentConfigurator (Object *implementation);
 virtual ~ComponentConfigurator ();

 virtual int hook (const char *hookName, ComponentConfigurator *cc);
 virtual int unhook (const char *hookName);
 virtual int registerClient (ComponentConfigurator *client, const char *hookName);
 virtual int unregisterClient (ComponentConfigurator *client);

 virtual int eventOnHookedComponent (ComponentConfigurator *hookedComp, Event e);
 virtual int eventOnClient (ComponentConfigurator *client, Event e);

 virtual char *name ();
 virtual char *info ();
 virtual char *listHooks ();
 virtual ComponentConfigurator *getHookedComponent (const char *hookName);
 virtual DependencySpecification *listHookedComponents ();
 virtual DependencySpecification *listClients ();
 virtual Object *implementation ();
}
\end{verbatim}
\end{center}
}
\end{slide}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\begin{slide}
\heading{Web Browser Example}
\begin{figure}[h]
  \begin{center}
    \leavevmode \epsfig{file=browser.eps,height=6.5cm}
  \end{center}
\end{figure}
\end{slide}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\begin{slide}
\heading{Automatic Configuration and Fault-Tolerance}

\begin{itemize}
\item \emph{Prerequisites} inform the OS or middleware what is needed.
\item \emph{Dynamic Runtime Dependencies}
\begin{itemize}
\item enable reconfiguration of running components
\item and enable smooth exception handling.
\end{itemize}
\end{itemize}

\end{slide}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\begin{slide}
\heading{Component Destruction}
{\small
\begin{center}
\begin{verbatim}
ComponentConfigurator::~ComponentConfigurator ()
{
  for (c in hookedComponents)
    c.configurator->unregisterClient (this);

  for (c in clients)
    c.configurator->eventOnHookedComponent (this, DELETED);

  // delete list of hooks and hooked_components 
  // delete list of clients
  // release resources
  // delete component implementation
}// ~ComponentConfigurator ()
\end{verbatim}
\end{center}
}
\end{slide}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\begin{slide}
\heading{The \texttt{valid} flag}
{\scriptsize
\begin{center}
\begin{verbatim}
ComponentConfigurator::~ComponentConfigurator()
{
  this->valid = this->implementation()->valid = False;
  // release resources

  for (c in hookedComponents) {
   c.configurator->unregisterClient (this);
  }
  // delete list of hooks and hookedComponents 

  for (c in clients) {
   c.configurator->
      eventOnHookedComponent (this, DELETED);
  }
  // wait until list of clients becomes empty
  // delete list of clients
  // delete component implementation
}// ~ComponentConfigurator ()

\end{verbatim}
\end{center}
}
\end{slide}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\begin{slide}
{\small
\begin{center}
\begin{verbatim}
inline int 
ComponentConfigurator::eventOnHookedComponent 
         (ComponentConfigurator *cc, Event e)
{
  if (e == DELETED) {
   this->deletionEventList.add (cc);
   return;
  }
  else ...
}
\end{verbatim}
\end{center}
}
\end{slide}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\begin{slide}
\heading{Solutions}
\begin{itemize}
\item Primitive
\item \texttt{valid} flag
\item Leases
\item Reflective Method Invocation
\item CORBA
\end{itemize}

\end{slide}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\begin{slide}
\heading{Related Issues}

\begin{itemize}
\item Programming Environment \\ (C++, Java, OpenC++, CORBA)
\item Security
\item Quality of the Reconfiguration Service
\item Reconfiguration Decision Making
\item Synchronization
\end{itemize}

\end{slide}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\begin{slide}
{\small
\begin{center}
\begin{verbatim}
int WebBrowserConfigurator::eventOnHookedComponent 
                      (ComponentConfigurator *cc, Event e) 
{
 if (cc == myJVMConfigurator)
  {
   if (e == REPLACED)
    try {   
         FrozenObjects frozenObjs = myJVM->freezeAllObjects ();
         myJVM = myJVMConfigurator->implementation ();
         myJVM->meltObjects (frozenObjs);
         myLogger->eventOnClient(this, RECONFIGURED(newJVM));
    }
    catch (Exception exp)
      throw new ReconfigurationFailed(exp); 
  }
 else ...
}
\end{verbatim}
\end{center}
}
\end{slide}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%\begin{slide}
%\heading{Other Related Issues}

%\begin{itemize}
%\item Naming
%\item 
%\item 
%\item 
%\end{itemize}

%\end{slide}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\begin{slide}
\heading{Overview}
\begin{enumerate}
\item \lolite{Introduction} %%%%%%%%%%%%%
\item \lolite{The Problem}
\item \lolite{The Proposed Solution}
\item \hilite{Completed Work}
\item \lolite{Related Work}
\item \lolite{Proposed Research Plan}
\item \lolite{Conclusion}
\end{enumerate}
\end{slide}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\begin{slide}
\heading{Completed Work}

\begin{itemize}
\item Model for representing inter-component dependence [KC98].
\item Implementation of a C++ framework to represent dynamic runtime
dependencies.
\begin{itemize}
\item deployed in \emph{dynamicTAO} [RKC98].
\end{itemize}
\item Implementation of a Java framework.
\begin{itemize}
\item in use by researchers at the University of S\~ao Paulo in two
prototype applications related to mobile agents and parallel computing.
\end{itemize}
\end{itemize}

\end{slide}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\begin{slide}
\heading{Completed Work: \emph{dynamicTAO}}

\begin{itemize}
\item TAO: a portable, flexible, extensible, and configurable CORBA-compliant ORB.
\item ORB engine aspects encapsulated in \emph{strategies}.
\item Strategies for concurrency, request demultiplexing, scheduling,
connection management, etc.
\item Tailored to static, hard real-time systems \leadsto no~support for
dynamic reconfiguration.
\vspace{5mm}
\item \emph{dynamicTAO}: supports on-the-fly reconfiguration of ORB strategies.

\item Did experiments with:
\begin{itemize}
\item Concurrency 
\begin{itemize}
\item single-threaded
\item thread-per-connection
\item thread-pool
\end{itemize}
\item Authentication
\begin{itemize}
\item null
\item Cherubim
\end{itemize}
\end{itemize}

\vspace{1cm}

\item Also enables dynamic configuration of CORBA servants.
\end{itemize}

\end{slide}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\begin{slide}
\heading{Safe Reconfiguration of a running ORB}

\begin{itemize}
\item Replacing a strategy $S_{old}$ by $S_{new}$ brings two problems:
\begin{enumerate}
\item $S_{old}$ cannot be unloaded if someone is using it.
\item Strategy-specific state may need to be transfered from the old to the new.
\end{enumerate}

\vspace{1cm}

\item These problems were successfully addressed with the help of the
\texttt{ComponentConfigurator} framework.
\end{itemize}

\end{slide}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\begin{slide}

\heading{Remote Configuration of \dTAO{} strategies}

\begin{figure}[htb]
  \begin{center}
    \leavevmode \epsfig{file=SimpleTAOConfigurator.eps,height=5.6cm}
  \end{center}
\end{figure}

\end{slide}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\begin{slide}
\heading{Overview}
\begin{enumerate}
\item \lolite{Introduction} %%%%%%%%%%%%%
\item \lolite{The Problem}
\item \lolite{The Proposed Solution}
\item \lolite{Completed Work}
\item \hilite{Related Work}
\item \lolite{Proposed Research Plan}
\item \lolite{Conclusion}
\end{enumerate}
\end{slide}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\begin{slide}
\heading{Related Work}

\begin{itemize}
\item Prerequisites
\begin{itemize}
\item SOS (INRIA: Shapiro)
\item SunOS shared libraries
\end{itemize}

\item WYNIWYG
\begin{itemize}
\item Microkernels
\item Exokernels
\item Choices (Customizable OS)
\end{itemize}

\newpage
\heading{Related Work}
\item Programming models
\begin{itemize}
\item Reflective Programming
\item Aspect-Oriented Programming
\end{itemize}

\newpage
\heading{Related Work}
\item Dynamic Configuration
\begin{itemize}
\item Connectors (CMU: Mary Shaw) \\ (Irvine, CA: Oreizy, Taylor, and Rosenblum)
\item Composite Objects \\ (Milan, Italy: Bertino and Guerrini)
\item Workflow Models \\ (Newcastle, UK: Shrivastava and Wheater)
\item Dynamic Reconfiguration Service for CORBA \\ (IRISA, France: Val\'erie Issarny)
\end{itemize}
\end{itemize}

\end{slide}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\begin{slide}
\heading{Overview}
\begin{enumerate}
\item \lolite{Introduction} %%%%%%%%%%%%%
\item \lolite{The Problem}
\item \lolite{The Proposed Solution}
\item \lolite{Completed Work}
\item \lolite{Related Work}
\item \hilite{Proposed Research Plan}
\item \lolite{Conclusion}
\end{enumerate}
\end{slide}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\begin{slide}
\heading{Proposed Research Plan}

Demonstrate the effectiveness of reifying inter-component dependence to
support automatic configuration. 

\vspace{8mm}

\begin{enumerate}
\item Development of a theoretical model for dependence
representation.
\item Development of a software framework implementing the model.
\item Deployment of the framework in two real-world applications.
\end{enumerate}
\end{slide}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\begin{slide}
\heading{1. Theoretical Models}

\begin{itemize}
\item Prerequisites
\begin{itemize}
\item investigate different representations
\item prerequisite interpreter
\item prerequisite resolver
\end{itemize}
\item Runtime Dependence representation
\item Specify theoretical assumptions about environment and components
\end{itemize}

\end{slide}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\begin{slide}
\heading{2. Software Infrastructure}

\begin{itemize}
\item Extend prototype to handle distributed components (CORBA, Java RMI).
%\item Extend prototype to handle nested components.
\item Implement simple prerequisite-interpreter.
\item Implement pull-based prerequisite-resolver.
\end{itemize}

\end{slide}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\begin{slide}
\heading{3. Experimentation}

\begin{itemize}
\item Deploy the framework in \dTAO, a centralized application.
\item Deploy the framework in the Multimedia Reflector, a distributed
application.
\item Analyze performance of the reconfiguration process supported by the prototype.
\end{itemize}

\end{slide}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\begin{slide}
\heading{Automatic Reconfiguration of a Multimedia Reflector}
\begin{center}
\begin{figure}[h]
\epsfig{file=reflector2streams.eps,height=5.2cm}
\end{figure}
\end{center}
\begin{itemize}
\item WYNIWYG
\item manage topology to take care of faulty nodes
\end{itemize}
\end{slide}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\begin{slide}
\heading{Original Contributions}

\begin{enumerate}
\item A methodology for building component-based applications in which dynamic
reconfiguration is driven by architectural awareness.
\item CORBA-compliant ORB supporting dynamic reconfiguration of the ORB engine.
\item Fault-tolerant, dynamically configurable multimedia Reflector.
\end{enumerate}

\end{slide}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\begin{slide}
\heading{Conclusions}

\begin{itemize}
\item Existing systems lack a model for representing inter-component
dependence which harms their configurability, manageability, and reliability.
\item This thesis will demonstrate:
\begin{enumerate}
\item A theoretical model and a software framework for reifying inter-component dependence.
\newpage
\item how the model can be applied to real-world
applications to support three different kinds of automatic configuration:
\begin{enumerate}
\item To support safe, on-the-fly reconfiguration of a reflective ORB.
\item To support fault-tolerance (adapting the topology of~the reflector
network to cope with faulty nodes).
\item To configure the Reflector code dynamically, implementing the WYNIWYG
model.
\end{enumerate}
\end{enumerate}
\end{itemize}

\end{slide}

\end{document}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\begin{slide}
\heading{}

\begin{itemize}
\item 
\item 
\item 
\item 
\end{itemize}

\end{slide}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\begin{slide}
\heading{}

\begin{itemize}
\item 
\item 
\item 
\item 
\end{itemize}

\end{slide}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\begin{slide}
\heading{}

\begin{itemize}
\item 
\item 
\item 
\item 
\end{itemize}

\end{slide}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\end{document}
