slides.tex

柯老师网站上找到的

\item switch between shared trees and source specific trees
\item does not capture transience well
\end{comment}

\foilhead{\indigo Centralised Dense Mode Configuration}
\begin{itemize}
\item computes parent-child relationships prior to start of simulation
\item Can study membership dynamics
\item No response to topology changes
\item Only one configuration parameter
\begin{program}\small
  DM set PruneTimeout \tup{newValue} \; default \(0.5s.\);
\end{program}
\end{itemize}

\begin{comment}
\item DVMRP-like 
\item works well in conjunction with static unicast routing
\end{comment}

\foilhead{\indigo Dynamic Dense Mode Configuration}
\begin{itemize}
\item Extension of static dense mode
\item As before, computes parent child relationships at start of simulation
\item Also recomputes whenever topology changes,
  or unicast route updates are received
\item Configuration parameters are:
  \begin{program}\small
    dynamicDM set PruneTimout \tup{newValue} \; default \(0.5s.\);
    dynamicDM set ReportRouteTimeout \tup{newvalue} \; default \(1s.\);
  \end{program}
\end{itemize}

\begin{comment}
\item one object per node
\end{comment}

\foilhead{\indigo PIM Dense Mode Configuration}
\begin{itemize}
\item Extension of static dense mode
\item does not compute parent child relationships
\item Configuration parameters are:
  \begin{program}\small
    pimDM set PruneTimout \tup{newValue} \; default \(0.5s.\);
  \end{program}
\end{itemize}

\begin{comment}
\item one object per node
\end{comment}

\foilhead{\indigo Other protocol work in progress}
\begin{list}{}{}
\item Detailed PIM
  \begin{list}{}{}
  \item Sparse mode and Dense mode
  \end{list}
\end{list}

\begin{comment}
  \item will be a comprehensive implementaiton of PIM
\end{comment}

\foilhead{\red Multicast Classes}

\placefig{mcastArch}

\begin{comment}
\item \verb|\placefig{mcastArch}|
\item mirros unicast route architecture
\item global centr mcast comp module
\item relies on centr rp compmodule
\item default computation for rp
\item General Multicast:
McastProtocol      -- mcast protocol mechanism (DM, 
dynamicDM)
McastProtoArbiter  -- mcast arbiter
Classifier/Replicator/Demuxer   -- mcast classifier (parse pkts, get 
(s,g,iif), and forward to (s,g,iif) replicator)
Classifier/Multicast/Replicator -- replicator for each (s,g, iif) (
copy pkts and forward to all oifs)

\item Centralized Multicast:
CtrMcast     -- install mcast routing entries per node
CtrMcastComp -- compute mcast trees via unicast routing table
CtrRPComp    -- compute RP Set for shared trees
\end{comment}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\foilhead{\blue Network Dynamics}
The ability to make elements of topology fail/recover.
\begin{itemize}
\item Model of failure and recovery

  --- Exponential, Deterministic, Trace driven, Manual (or one-shot)

\item Operates on single link

  --- \textsl{i.e.} takes link ``down'' or ``up''

\item Operation on single node possible, translated into operation
  on collection of links incident on node
\end{itemize}
\keyword{Network Dynamics}

\begin{comment}
\item currntly only possible to specify single link or node
\item no clustering yet
\end{comment}

\foilhead{\indigo Specification}
\begin{itemize}
\item Create an instance of \tup{model}
  \begin{program}
    $ns \textbf{rtmodel} \tup{model} \tup{parameters} \tup{node|link}
  \end{program}
  Command returns the handle of the model created
\item Perform \tup{operation} at \tup{time} on \tup{node|link};
  \begin{program}
    $ns \textbf{rtmodel-at} \tup{time} \tup{operation} \tup{node|link}
  \end{program}
  return handle to newly created instance of model.
\item Delete route model specified by \tup{handle}
  \begin{program}
    $ns \textbf{rtmodel-delete} \tup{handle}
  \end{program}
\end{itemize}

\begin{comment}
\item interface through thte class simulator
\item operates only on node and link
\item multiple arguments are ignored
\end{comment}

\foilhead{\red Models and Configuration}
\begin{enumerate}
\item Exponential
  \begin{sublist}
  \item \tup{[startTime], upInterval, downInterval, [endTime]}
  \end{sublist}
\item Deterministic
  \begin{sublist}
  \item \tup{[startTime], upInterval, downInterval, [endTime]}
  \end{sublist}
\item Trace (based)
  \begin{sublist}
  \item \tup{fileName}
  \end{sublist}
\item Manual (or one-shot)
  \begin{sublist}
  \item \tup{operation, time}
  \end{sublist}
\end{enumerate}

\begin{comment}
\item time vagaries
\item trace file format
\item Long form of the \code{rtmodel-at}
\end{comment}

\foilhead{\red Defining your Own Model}
Derive model from the base class, \code{rtModel}

\begin{tabularx}{\linewidth}{crX}
1. & \proc[]{set-parms} & process model parameters \\
2. & \proc[]{set-first-event} & specify the first event \\
3. & \proc[]{up}, \proc[]{down} & specify next action \\
\end{tabularx}

--- Use class rtQueue to schedule events.

--- Instance of queue in rtModel class variable, \code{rtq_}

\begin{comment}
\item comments on each procedure; defaults
\item use rtQueue to installe vents
\end{comment}

\foilhead{\red class rtQueue}
Internal class to synchronise topology change activity

\begin{tabularx}{\linewidth}{rX}
\proc[]{insq} & Given \tup{time}, \tup{object},
        and an instance procedure for that object and arguments,
        will invoke instance procedure of object at specified time. \\
\proc[]{insq-i} & identical to \proc[]{insq}, except \tup{time}
        specifies increment when the procedure will be executed\\
\proc[]{runq} & executed procedures for the specified time;
        finish by invoking \proc[]{notify} for each object \\
\proc[]{delq} & remove event for object at specified time
\end{tabularx}

\begin{comment}
\item need for synchronisation: route advertisement staggerring
\item possibly obviated by the timer interface in OTcl
\end{comment}

\foilhead{\red Interface to Unicast Routing}
\placefig{uni-nd-intf}

\begin{comment}
\item Layer of focus in next slide
\end{comment}

\foilhead{\red Interface to Unicast Routing}
\placefig{ndactions}

\begin{comment}
\item \verb|\placefig{ndactions}|
\item sequence of events upto routing interfaces
\end{comment}

\foilhead{\indigo Deficiencies in the Network Dynamics API}
\begin{itemize}
\item Link centric
\item Node failure not consistent with an operation model
\item API cannot specify clusters/clouds
\end{itemize}

\begin{comment}
\item no way to specify other than node or link
\item node not reset on failure
\item node emulation is broken concept
\end{comment}



%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\foilhead{\blue Multicast Transport}
Currently, SRM and RTP implemented
\begin{itemize}
\item goals of implementation:  programmability
\item in particular, for SRM: programming timers,
session message handling, loss recovery
\item and for RTP, mostly programmed in OTcl, with
  minimalpacket related statistics counters in C++
\end{itemize}
\keyword{Multicast Transport}    % 20

\begin{comment}
\item most implementation is in OTcl, limited C++ handling,
\item confined to packet level activities
\item for RTP, per packet statistics is in C++
\item for SRM, packet forwarding, sending/receipt of packets, and
processing session messages
\end{comment}

\foilhead[-3ex]{\indigo Simple SRM configuration}
\begin{program}
  set ns [new Simulator]          \; preamble initialization;
  $ns enableMcast
  set node [$ns node]                \; agent to reside on this node;
  set group [$ns allocaddr]           \; multicast group for this agent;

  {\bfseries{}set srm [new Agent/SRM]}
  $srm  set dst_ $group            \; configure the SRM agent;
  {\bfseries{}$ns attach-agent $node $srm}

  $srm set fid_ 1                \; optional configuration;
  {\bfseries{}$srm log [open srmStats.tr w]}   \; log statistics in this file;
  {\bfseries{}$srm trace [open srmEvents.tr w]}  \; trace events for this agent;

  set packetSize 210
  # {\cf{} configure the traffic generator and traffic source}
  set s0 [new Agent/CBR/UDP]   \; attach traffic generator to application;
  $s0 attach-traffic $exp0
  {\bfseries{}$srm(0) traffic-source $s0} \; attach application to SRM agent;
  {\bfseries{}$srm(0) set packetSize_ $packetSize} \; to generate repair packets of appropriate size;

  {\bfseries{}\fcnref{$srm start}{../ns-2/srm.tcl}{Agent/SRM::start}}
  {\bfseries{}\fcnref{$srm start-source}{../ns-2/srm.tcl}{Agent/SRM::start-source}}
\end{program}

\begin{comment}
\item Acquire and configure agent
\item Attach agent to node
\item open log and trace files as required
\item configure a traffic generator and traffic source
\item attqach application to agent
\item notice setting packet size
\item start agent and traffic source separately
\end{comment}

\foilhead{\indigo Class Hierarchies}
\placefig{srmhierarchy}

\begin{comment}
\item Separate loss recovery objects
\item separate session message handling object
\item Loss detection is in C++,
\item loss recovery is in OTcl
\item number of bottlenecks in memory are expected
\item wait for scaling issues following
\end{comment}

\foilhead{\indigo Loss Detection}
\begin{list}{}{}\item
Triggered by receipt of data or control messages

\item
\begin{program}
  $agent \textbf{request} \tup{sender} \tup{list of messages}
\end{program}

\item
Actual loss recovery occurs in OTcl through special purpose
loss recovery  objects
\end{list}

\begin{comment}
\item single reqeust helps speedup scheduling
\item also help schedule request periods for statis gathering simple
\end{comment}

\foilhead{\indigo Loss Recovery}
\begin{itemize}
\item Each loss is handled by separate ``SRM'' object.
\item Nodes schedule ``request'' or ``repair'' objects following
  a data loss
\item Each loss recovery object handles its own scheduling and messaging
  activity
\end{itemize}

\begin{comment}
\item each agent also receives its messages
\item relies on agent being able to receive its own messages
\end{comment}

\foilhead{\indigo Session messages}
\begin{itemize}
\item One session message handling object per agent
\item Responsible for sending periodic session messages
\item Session message interval controlled by class variable, 
  \code{sessionDelay_}
\item Two types of session functions implemented:
  \begin{subenum}
  \item SRM/Session uses default fixed interval session message sending
  \item SRM/Session/logScaled uses $\log({\rm groupSize\_}) * {\rm
      sessionDelay\_}$  to send next advertisement. 
  \end{subenum}
\end{itemize}

\begin{comment}
\item advantages etc.
\end{comment}

\foilhead{\indigo Statistics}
\begin{enumerate}
\item Agent---response to Data Loss:  Detection and Recovery
\item Loss Object---Per Loss recovery Statistics 
\end{enumerate}

\begin{comment}
\item data loss measures ave-recovery delay, ave dups
\item used by adaptive algorithm to adjust the recovery parameters
\item Loss recovery objects write out to log file when they terminate
\end{comment}

\foilhead{\indigo Tracing}
\begin{itemize}
\item Per event tracing by loss recovery objects
\item Sample trace file is:
\begin{program}
 3.5543 n 1 m <1:1> r 0 Q DETECT
 3.5543 n 1 m <1:1> r 1 Q INTERVALS C1 2.0 C2 0.0 d 0.0105 i 1
 3.5543 n 1 m <1:1> r 1 Q NTIMER at 3.57527
 ...
 3.5753 n 1 m <1:1> r 2 Q NACK IGNORE-BACKOFF 3.59627
 3.5828 n 3 m <1:1> r 0 Q DETECT
 3.5828 n 3 m <1:1> r 1 Q NTIMER at 3.6468
 3.5854 n 0 m <1:1> r 0 P NACK from 257
 3.5854 n 0 m <1:1> r 1 P RTIMER at 3.59586
 3.5886 n 2 m <1:1> r 2 Q NTIMER at 3.67262
 3.5886 n 2 m <1:1> r 2 Q NACK IGNORE-BACKOFF 3.63062
 3.5959 n 0 m <1:1> r 1 P SENDREP
 ...
\end{program}
\end{itemize}

\begin{comment}
\item done by loss objects
\end{comment}

\foilhead{\indigo RTP}
\begin{itemize}
\item Session/RTP tracks incoming data, and sends periodic delivery
  reports.
\item Agent/CBR/RTP sends data to the group at a specified rate.
\end{itemize}

\begin{comment}
\item need slides on RTP
\item RTPSource adjunct class to set src id, but not clear it if
  generates
data.
\item report-interval, session bw etc. can be controlled.
\item CBR agent generates data, and when it recvs from outside
hands it to session to generate report
\end{comment}

\foilhead[-2ex]{\blue Multicast Transport Starter Kit}
\begin{itemize}
\item Code and Documentation:  SRM and RTP

\item Multiple flavours of multicast
  
  {\small
  includes Dense mode, Sparse mode, centralised multicast, session level
  multicast
  }

\item Multiple flavours of unicast and network dynamics

  {\small
  Ability to study the problem under dynamic topologies, including
  partition scenarios
  }

\item Multiple physical layers including broadcast and wireless LANs

\item building a catalog of canonical topologies

\item Examples in \nsf{tcl/ex}

\item test suite in development
\end{itemize}