- Analytical approaches cannot handle realistic networks features, including most kinds of feedback.
- Numerical solutions are unmanageable for realistic networks (because the state space becomes enormous).
- Discrete-event simulations are unmanageable for realistic networks (because of number of scheduled events becomes enormous).
- control state (state of the control algorithms)
- target system arrival rates (part of target system specification)
- MCMR arrival rates (inferred from target system arrival rates and control state)
- MCMR performance measures
- target system performance measures (inferred from the MCMR measures and control state).
- time of the next control algorithm update.

**Time-dependent queueing systems** are undoubtedly the natural modeling
tool. Their arrival and service rates can be functions of delayed system
state, and solving them yields transient responses to network and workload
changes. However these systems are not tractable by traditional approaches:

- The

The **encapsulation
approximation** represents a system by an ``interface'' of relationships
between instantaneous measures of the system. Given such an encapsulation
of a system, we can compute instantaneous performance measures of a larger
system containing the encapsulated system without ``opening up'' the encapsulated
system.

The **decomposition
approximation** approximates multi-class multi-resource models by a collection
of loosely-coupled multi-class single-resource models. This again reduces
the dimensionality of the Chapmann-Kolmogorov equations.

(**Example:** Consider an adaptive routing network with workload
defined in terms of classes, each specifying a source node, a destination
node, a packet arrival rate, and a packet service rate; the routing algorithm
chooses from among the several paths available for each class. This target
system can be converted to a MCMR queue with a resource for each link of
the network and a class for each pair of workload class and possible path.
Thus the arrival rate of a MCMR class depends on the arrival rate of its
target system class and the current routing state.)

At any time t, the prototyper maintains the following:

The **Z-prototyper
package** implements the above evaluation method. It has the following:

- A

A **simulation library**
of functions for *simulating* MCMR queues. This simulator is provided
for validation purposes only; in general, it will take far more computation
time than the Z-iteration evaluator.

A **common API**
for the simulation and Z-iteration libraries. Thus an application can readily
switch between the two evaluation methods.

A collection of **target
system models**. Currently they are of connection-oriented *flat and
hierarchical *networks with dynamic routing, link scheduling, admission
control (and the resulting resource reservation). Each target workload
class represents a stream of connection requests with the following attributes:
source and destination node for the connection requests, rate at which
the requests are generated, traffic descriptors of the requests (eg, peak
and avg rates, burstiness), desired QoS of the requests (eg, end-to-end
delay/jitter of either statistical or deterministic flavor, maximum loss
probability), and duration of established connections.

An **on-line network
evaluator** of the above connection-oriented networks. The on-line evaluator
has a java applet for constructing target systems, a server (not an applet)
for doing Z-iteration evaluation, and a collection of predefined target
systems. It is best run using Sun's appletviewer, which comes with the
Java(tm) Development Kit.

The on-line network evaluator (client only) is also available as a separate package.

You are welcome to
try the on-line
network evaluator through a web browser (Netscape
4.0 or higher).

An application to a network with routing, admission, and scheduling control can be found here.

An application to a hierarchical network with various state aggregation schemes can be found here.