Handling Heterogeneity in Networked Virtual Environments

Helmuth Trefftz 1, Ivan Marsic 2 and Michael Zyda 31 and 2 CAIP Center, Rutgers University 3 The MOVES Institute, Naval Postgraduate School

trefftz@caip.rutgers.edu, marsic@caip.rutgers.edu, zyda@movesinstitute.org

Abstract

The availability of inexpensive and powerful graphicscards as well as fast Internet connections makeNetworked Virtual Environments viable for millions ofusers and many new applications. It is thereforenecessary to cope with the growing heterogeneity thatarises from differences in computing power, networkspeed and users’ preferences. This paper describes anarchitecture that accommodates the heterogeneitymentioned above while allowing a manager to definesystem-wide policies. Policies and users’ preferences canbe expressed as simple linear equations forming amathematical model that describes the system as a wholeas well as its individual components. When solutions tothis model are mapped back to the problem domain,viable solutions that accommodate heterogeneity andsystem policies are obtained. The results of ourexperiments with a proof-of-concept system aredescribed.

1. Introduction

Powerful computer graphics cards are becoming lessexpensive and most new computers ship with cards thatare capable of displaying complex 3D scenes atinteractive rates. Similarly, high-speed connections to theInternet are becoming increasingly common. These factsallow for a potential widespread use of DistributedVirtual Environments (DVEs) or Networked VirtualEnvironments, as described in [6].

In a controlled environment, the DVE designer candetermine a-priori the type of computers and networkconnections that will be involved in the system. TheDVE can then be engineered to perform well within thegiven conditions. But as DVEs find their ways to realworld applications, the environments cannot be so easilycontrolled. Heterogeneity arises in different forms:• Nodes with a wide variety of computing resources

(processor speeds, available memories, graphiccards).

• Varying connection type of the nodes (from modemlines to local area networks).

On the other hand, designers of DVEs need to be ableto determine certain system-wide constraints in order toguarantee productive use of the system. Examples of

these policies are: maximum number of concurrent users,minimum frame-rate that each node must be able tomaintain, maximum number of messages per unit of timethat can be handled by the system, etc.

On one hand then, we have the heterogeneity thatarises from the diverse participating nodes and fromindividual users preferences. On the other hand we havethe need to provide the designer with the ability to dictateand enforce certain homogeneity of function.

1.1. Contributions of this Work

In this paper, we propose a client-server architecturethat we call Switchboard Architecture (SA) that copeswith the conflicts described above. The structure of theSA makes it possible to map individual user preferencesas well as system constraints to linear equations andinequalities. This set of equations and inequalities form amathematical model that describes how the systemfunctions. Valid solutions to the mathematical models areisomorphic with states of the DVE in which individualusers’ preferences are satisfied as closely as possiblegiven the restrictions imposed by the hardware and theconstraints defined by the DVE designer.

There are two main contributions of this work:• The Switchboard Architecture, which can be used

in other client-server DVEs.• The mathematical model that approximates the

functioning of the DVE system. The modelprovides an objective and automatic way to copewith the opposing tendencies of heterogeneity andhomogeneity in DVEs.

The rest of this paper is organized as follows: Section2 describes related work. Section 3 describes theSwitchboard Architecture, as well as the generic form ofthe corresponding mathematical model. Section 4 and 5describe the results we have obtained with a sharedvisualization program we have built incorporating theprinciples we describe. Section 6 presents theconclusions and future work.

2. Related Work

One of the most desirable conditions in a DVE is toprovide all participants with a consistent and up-to-date

version of the shared space. But in the presence ofimperfect communication channels, the time to replicatethe shared state among participants is not zero, giving riseto the Consistency-Throughput tradeoff [6]. As thenumber of participants and entities taking part in the DVEincrease, the number of messages and the amount ofcomputation necessary to keep a consistent versionincrease exponentially.

An important related area of research in DVEs dealswith the architecture for building a DVE system. Anextensive survey of architectures can be found in [4] .

A large amount of research in DVEs has beendedicated to reducing the number of messages and thecomputational load needed to keep a consistent, yetpossibly distributed, description of the virtual world, withthe main objective being scalability.

One area of research that addresses this problem dealswith Area of Interest Managers (AOIM). Only messagespertaining to the current area of interest of the users areconveyed to their nodes with high priority. Macedonia[5] describes a way to map multicast groups togeographical regions. As a user traverses the simulationfield, he/she leaves some regions and enters others,changing the multicast groups he/she uses to exchangemessage with other participants in the same regions.

Having several levels of representation for the virtualobjects can also reduce the amount of computation doneat each node. Objects that are far from the observer or ofless interest for the user can be rendered with lowerfidelity. Capps [1] defines a framework for managing thedisplay and request of representations for virtual objectscalled QUICK. Objects are annotated with ameasurement for Quality, Importance and Cost. Thesystem optimizes the total fidelity contribution whileminimizing the cost.

Reducing the number of messages used to keep aconsistent state of the system is another goal. Most ofthese techniques make use of dead reckoning, whichinvolve sending not only the position but also thetrajectory of a moving object. If each participant canlocally compute the position based on the trajectory, onlychanges to the trajectory need to be sent. Faisstnauer etal. [2] propose an algorithm to schedule outgoingmessages. Messages that describe updates to objects thatdeviate more from their previously sent trajectories aregiven higher priority. The result is that the overallsystem-wide error is minimized. In small DVEs, thedifferences in performance between the participatingnodes can also be exploited. If a particular node issending updates faster than the other nodes can processthem, bandwidth and resources are being wasted. In aprevious paper [9], we explored this issue and obtained adecrease in bandwidth utilization as well as improvedresponsiveness in slower nodes. Terrence and Dew [8]make a theoretical characterization on the number of

messages that can be dropped in order to keep a goodframe rate in a Collaborative Environment.

Being able to manage the Quality of Service providedto the participants is a desirable feature. Greenhalgh etal. [3] propose a system that allows users to exchangevideo streams in a virtual environment. The scarcemulticast groups are assigned to users based on theinterest of the users and their proximity in the virtualenvironment.

3. Our Approach

As discussed in the introduction, conflict can arisebetween the constraints imposed by the designer of aCVE and the heterogeneity that results from nodediversity and user preferences. Our approach provides amapping from the system-design domain to amathematical domain. This mapping is accomplished bymodeling the user preferences and the administratorconstraints as equations. Since a mathematicalcorrespondence can be defined between these twodomains, solving the model in the mathematical domainprovides for an objective and fair solution in the system-design domain. These relationships are depicted inFigure 1.

We discuss below how the mapping between the twoabove-mentioned domains can be accomplished.

3.1. Mathematical Model

The different dimensions of shared information thatcan be tuned by the user and, possibly, be enforced byglobal policies in the system, are called variables.Examples would include: the number of video frames persecond; the quality of visualization (wire-frame, shaded,etc.); the quality of sound (mono, stereo, 3D, etc.).Variables take on discrete possible values within a certainrange, determined by the computing power of the nodestaking part in a session. The Cartesian product of thepossible values of the different variables forms an n-dimensional search space, n being the number ofvariables. Assigning a fixed value to a variable can

Policies/Preferences Solution

Mathematical Model

Mathematical Solution

Figure 1. Mappings between the design and math domains.

directly affect the amount of computing power dedicatedto processing data related to it. Variables that are fixed inthis manner are called independent variables. Thedesigner might allow the operating system to freelyallocate computing power to other variables, which willthen take values depending on the fixed-value variablesand other factors. These are called dependent variables.

Our approach works by controlling certain variablesand letting the operating system (OS) assign all remainingcomputing power to the dependent variables. The amountof computing power dedicated to the dependent variableswill depend on the total computing power of the node, theavailability of specialized processors and OS schedulingpolicies. The value of the dependent variables willtherefore vary from one node to another. The values thatthe dependent variables take in a particular node, for agiven set of independent variables, depend on theperformance of each node. This mapping is called theperformance mapping. The performance mapping isdetermined by a set of benchmarks run at eachparticipating node before the beginning of thecollaborative session.

Global policies can be expressed as inequalities overcertain variables. An example of a global policy mightbe: “Each system must be able to display at least 2 videoimages per second”.

An Individual’s preferences can be expressed as alinear combination of the variables. The normalizedcoefficients of the variables determine their relativeimportance. Normalization of the coefficients must bedone carefully, taking into account the ranges of theinvolved variables.

Global policies partition the space into validsubspaces. The intersection of these valid subspaces is,in turn, either a finite or an infinite n-dimensional space.In order to enforce the global policies, variables at eachnode are limited to taking only values that lie inside theintersection of valid subspaces. The points of the searchspace that lie inside the intersection of valid subspacesform the valid search space.

The linear combination of variables that describes theindividual preferences becomes the objective function,which needs to be maximized. The function is evaluatedat each point of the valid search space looking for amaximum. The optimum values of the dependentvariables are assumed to be the results of the performancemapping at the point that maximizes the objectivefunction. The user controls the coefficients of theobjective function through a control panel with onesliding control for each variable. Moving up the sliderfor one variable means assigning more relativeimportance to it, at the expense of another variable(s).

The mathematical model consists of the followingparts:• Each user’s objective function, of the following form:

×+× ∑∑ j

jji

ii DWIWMax (1)

Here, I are the normalized values of the independentvariables;D are the normalized values of the dependentvariables;W are the weights representing the user’s preferences.

• Constraints representing minimum informationrepresentation levels have the following form:

ii KI ≥ (2)

K is the minimum level of information representationallowed for variable Ii.

• Constraints limiting the maximum number ofmessages the server can process per unit time have thefollowing form:

∑ ≤k

ik LV (3)

Here, L is the maximum number of messages relatedto variable V that the server can process per unit time.Sub-index k covers all participants in the CVE.Linear equations of type (1), (2) and (3) together form

the mathematical model, which is similar in form to alinear programming problem. But the model cannot behandled with linear programming techniques because thevariables do not take continuous values and because thedependent variables are not linear with respect to theindependent variables (recall that the values of thedependent variables are obtained experimentally via theperformance mapping). However, given the small size ofthe search space, the objective function can be evaluatedat each valid point in order to find the maximum veryquickly. The values of the variables at the point wherethe objective function is maximized correspond to thefidelity level that the client must set in order to adapt aswell as possible to the user’s preferences while complyingwith the global policies.

Our approach works in two phases.• Off-line: Prior to actively joining the session, each

node runs a series of tests. During the tests, the nodeis set to work under the Cartesian product of theindependent variables, and the values of thedependent variables are measured and recorded(performance mapping). Thus, the search space ispredetermined for each node. It is assumed that

every node’s behavior will remain relativelyconstant.

• On-line: During the collaborative session, thesystem needs to adapt to changes that may occur.For instance, the user might change her preferences,thereby changing the relative importance of thevariables. A new search for the maximum valueinside the local valid search space has to beconducted. Or a new user might join the session,adding to the number of messages the server has toprocess.

3.2. The Switchboard Architecture

The architecture we propose is described in Figure 2.The server receives updates from the clients anddistributes those updates into the switchboard matrixaccording to each client’s capacity and user preferences.Each row of the switchboard handles a variable in thesystem. Updates for a specific variable from all theparticipating clients are received in the “receiving-plug”(Figure 2). The message is then buffered in a small cacheat each “transmitting-plug”. Each transmitting plug has anassociated timer controlling its transmission period.When the timer expires, all the updates stored in theplug’s cache are transmitted to the subscribed clients (if

any). In order to reduce traffic, each “transmitting-plug”is implemented as a multicast group.

In Figure 2, two clients and the server are described.Receiving-plugs are represented as the column on the leftinside the Server rectangle. Transmitting-plugs arerepresented as the matrix on right hand side of therectangle. Transmitting-plugs corresponding to morefrequent updates are located at the right hand side of thematrix. Note that updates coming from both clients arrive

at the same receiving-plugs (one per variable). Client n,running on a fast computer, subscribes to the highestfrequency of updates for variables 1 and 2, and to thelowest frequency of updates for variable m. The user onclient n is more interested on variables 1 and 2 than onvariable m. Client 1, running on a slow machine,subscribes to the slowest frequency of updates forvariables 1 and m, and to a rather slow frequency forvariable 2. The user at client 1 is more interested invariable 2 than on variables 1 and m.

The effect of this architecture is that the server acts asa buffer, providing slower nodes with a sub-sample ofmessages generated by faster nodes in a controlledmanner that is determined by the client node’s capacityand users’ preferences. The apparent jumpiness of theobjects which are updated less frequently can becompensated, to an extent, with dead-reckoning.

4. Experimental Setup

As a proof of concept for the architecture and themodel, a shared visualization system was built usingJava3D [7] . Figure 3 shows a screenshot of the system.

Three users meet virtually to discuss over a sharedvisualization data set. Users utilize “telepointers” (3Darrows) as means to point inside the virtual world. Smallvideo windows are provided to allow users to see thefaces of the other participants. Only one user canmanipulate the visualized object at a given time. Theapplication directly handles all the media related to thevariables in order to be able to optimize the objectivefunction. We could use third party applications, e.g., forvideo conferencing, if they provide APIs to control thelevel of fidelity and the statistics on the number of lostmessages.

4.1. Variables

The variables involved in the system are:• T: Telepointers update rate.• O: Visualization dataset update rate.• V: Video update rate• G: Graphical representation fidelity• F: Scene visualization frame rate.

Variables T, O, and V can take the following values: 0(no updates), 1, 2, 10 or 20 updates per second.

Variable G can take value 0 (wire-framerepresentation) or 1 (Phong shaded). Another use ofvariable G could be different levels of detail of thevisualization dataset. Higher level of detail wouldcorrespond to larger values of G.

Server

Client 1 Client n

Variable 1

Variable 2

Variable m

…

…

…

… … … …

Server

Client 1 Client n

Variable 1

Variable 2

Variable m

Server

Client 1 Client n

Variable 1

Variable 2

Variable m

…

…

…

… … … …

Figure 2. The Switchboard architecture. Each“plug” corresponds to a specific combination ofvariable and information fidelity. The column vectoron the left represents the receiving plugs and thematrix on the right represents the transmitting plugs.

Variables T, O, V and G are independent variables.Variable F is the dependent variable. The values F cantake are the result of the performance mapping, and varyconsiderably across machines.

Before using the values of the variables in theobjective function, they must be normalized by dividingthe current value by the maximum value of that variable.This operation maps the values of the different variablesinto dimensionless numbers between 0 and 1. Eachnumber expresses what fraction of the maximum fidelitylevel is set by the current variable value. Note that themaximum value for F is node-specific and is foundduring the performance mapping.

The ranges of the variables can be defined with finergranularity, thereby increasing the controllability of thesystem. But the search space would become larger andthe search more expensive.

The sliders shown in Figure 3 provide users with away to assign relative weight to the variables. The valuesof the sliders are normalized in order to obtain thecoefficients for the objective function as follows:

∑=

ii

ii S

SW (4)

Si are the values of the sliders, between 0 and 100.Wi are the values of the coefficients used in the objectivefunction, Eq. (1).

Note that the selection of the variables for the model is

specific to the application. In a battlefield simulation, forinstance, one variable might be assigned to slow movingvehicles, such as tanks and another to fast movingvehicles, such as airplanes. Users of one type of vehiclewill probably be more interested in (and will assignhigher priority to) messages originating from vehicles ofsimilar type.

4.2. Scenario for Applying the Model

Here we describe a typical scenario for employing ourmathematical model in a collaborative session.

Initially, a benchmark program is run on each node inorder to create the data for its particular performancemapping. The node subscribes sequentially to every pointin the Cartesian product of the dependant variables for acertain period long enough that the behavior of thedependent variables stabilizes. In our case the dependentvariable is frame rate and the required time is 5 seconds.The dimension of the search space in our example is 250(5 × 5 × 5 × 2). During that time, the server generatesfake updates for telepointers, object movement and video.Each message is marked with a sequence number, inorder to detect lost messages. At the node, an entry isadded to a vector every time a frame is displayed in orderto determine the average frame rate for the particularsearch space vertex. Additionally, for each message thatis processed, an entry is added to a vector, in order todetermine the number of lost messages at each searchspace vertex. When the benchmark finishes, the vectorsare saved to disk and summarized in a particularperformance mapping for the node.

Next, the collaborative session starts. Initially, theoptimizer module in the client finds the solution thatmaximizes the objective function that corresponds to allthe sliders at 50 (the sliders can take values between 1and 100). The client then subscribes to the server to theappropriate “plugs” and sets the fidelity of thevisualization dataset according to the current solution.

Information exchanged between the client and theserver regarding the mathematical model is meta-data andis sent through a TCP connection.

When the user moves the sliders in order to adjust therelative importance of a variable, the optimizer modulefinds a new solution. The search involves evaluating thepolynomial that represents the objective function at thevalid vertices (250 or less, since some of the searchvertices are marked as invalid). As result, it might benecessary to unsubscribe from a particular plug(associated with a fidelity level of a variable) andsubscribe to a different one.

Finally, the flow of the actual data between the clientand the server proceeds as described in Section 3.2. Inthe example system, each plug is associated with a non-

Figuare reuser

re 3. Screenshot of the system. Telepointerspresented as 3D arrows. The sliders allow the

to set the relative weights of different variables.

reliable multicast group and information is transmitted viaUDP.

In our current implementation, if a node is subscribedto receive a particular frequency of updates for a specificvariable, it will also send updates for that variable at thesame frequency. This is necessary in order to enforceequations of type (3), and allows the designer to specifyupper limits on the number of messages the server willneed to process for each variable.

5. Results

Table 1 gives the characteristics of the computers usedfor the experiments. The visualization dataset we usedfor these particular experiments is a representation of the

human digestive system, and consists of 27,202 vertices.

Table 1. Computers used in the experiments

Processor Processor Speed Memor

y

Graphics Card

Bachue

Pentium 4 1400MHz

1 GB GeForce2 –32MB

Bochica

dual PentIII

730MHz

1 GB FireGL 1 – 32MB

Morlak

Pentium II 500MHz

256MB

Intense3D – 16MB

The complete performance mapping cannot be graphedbecause it involves five (5) different variables. But a plotof the visualization frame rate (F) versus telepointersupdate (T) and video frame rate (V) is shown for Bachueand Bochica in Figures 4 and 5. Note the difference inthe scale.

Note also that as the frequency of video messagesincreases, the frame rate decreases noticeably, whereasthe impact of more frequent telepointer messages is small.Video messages have a larger impact on the simulationthan telepointers messages.

The solutions suggested by the math model aresensible and consistent with the data captured in theperformance mapping. For instance, when the maximumpriority is assigned to frame rate, the system lowers theresolution of the model to wire-frame and reduces the

0

10

0121020

0

0.2

0.4

0.6

0.8

1

video

telep

Morlak: Video Drop vs. video x telep

Figure 6. Percentage of video messages droppeddepending on the number of video and telepointersmessages per second (in Morlak).

0 1 2 10 200

1005

10152025303540

video

telep

Bachue: frame rate vs (video x telep)

Figure 5. Bachue: Impact of video and telepointerupdates on the frame rate.

0 1 2 10 200

1002468

101214

video

telep

Bochica: frame rate vs (video x telep)

Figure 4. Bochica: Impact of video and telepointerupdates on the frame rate.

frequency of the video updates, which negatively impactthe frame rate, as shown in Figures 4 and 5.

The number of lost messages is an importantparameter for measuring degradation of the system.Slower nodes drop more messages than faster ones underthe same load. Again, as the number of messages for aspecific variable increase past a certain threshold, so doesthe number of lost messages. Figures 6 and 7 show howthe number of lost video messages grows for Bochica andfor Morlak. Note that Bochica is capable of handlingvideo messages without dropping any until the frequencyexceeds 10 messages per second. In Morlak, a percentageof messages is always dropped. Notice also thedifference in scale. Bochica does not drop more than 6%of video messages, whereas Morlak drops up to 95% inthe worst-case scenario.

We have incorporated the number of droppedmessages during the benchmarks to the algorithm thatfinds the solution. Particular points in the Cartesianproduct of variables that are found to cause too manydropped messages cannot be chosen as solutions. If thenumber of dropped messages is not considered, thesepoints appear as good candidates for the solution, becausethe frame rate increases as messages are dropped andneed not be processed. In our current experiments, wemark a point non-valid if it causes more than 50% drop inmessages of any variable. In a real life application,different thresholds could be applied to differentvariables, according to the user’s perception and/orrelative importance.

Since the mathematical model is based on actual datacollected through the benchmarks, the solutions found forthe same set of slider values (directly related to theobjective function coefficients) vary considerably acrossnodes. Table 2 shows the solutions found at the differentnodes for the same set of user’s slider values. The user’ssliders were set to <T = 4, O = 4, V = 4, G = 51, F =100>. This set of sliders values assigns the highestimportance to frame rate, some importance to thegraphical representation of the model and very little to theremote events. Note that in both Bochica and Bachue(the faster machines) updates from the telepointers andobjects can still be received at maximum speed, withoutaffecting the frame rate. Morlak, on the other hand, hasto reduce the frequency of all remote updates. Note alsothat all nodes, fast and slow, need to reduce the frequencyof video updates, which have a big impact on the framerate.

Table 2. Solutions found at the different nodes for thesame set of user sliders values.

Teleptr. Object VideoResol’n

.

Morlak 1

Bochica

20

Bachue 20

In order to testutilizing the propsimulate 20 upd(telepointers, objecframe rate at each Architecture. The

The largest impslowest machine, weffect of the serveras follows: Bachu366%.

6. Conclusions

We have presenthe underlying matthat the architecenforcing global modify the charactto their preferences

The situations tpropose can be cha• Participating

computing pow• The modaliti

represented wspace/time dim

Figdepmes

0

10

0121020

00.010.020.030.040.050.06

video

telep

Bochica: Video Drop vs. video x telep

ure 7. Percentage of video messages droppedending on the number of video and telepointerssages per second (in Bochica).

2 1 120 2 1

20 1 1

the improvement in frame rate whenosed architecture, a node was set toates per second for each variablet, video). Data was collected about thenode with and without the Switchboardresults are shown in Figure 8.rovement is naturally obtained for thehich benefits most from the buffering

. The frame rate increases found weree: 33%, Bochica 10% and Morlak

and Future Work

ted the Switchboard Architecture andhematical model. Current results showture provides an effective way ofconstraints while allowing users toeristics of the user interface according.hat can benefit from the framework weracterized as follows:nodes have diverse degrees ofer.

es for sharing information can beith varying degrees of fidelity inensions.

• There is not enough computing power at each andevery node to represent at the same time all themodalities at their maximum level of fidelity.

In such an environment, our solution allows thefollowing to happen in a controlled manner:• Users can choose the fidelity or the modality for

information presentation to meet their preferences(within globally specified restrictions or policies).

• A global administrator can define global policiesregarding minimum requirements for informationrepresentation/sharing, as well as the maximumnumber of messages the server can process per unitof time.

The data collected in the benchmarks that are runbefore the collaborative sessions form a static snapshot ofthe system. If conditions change during the collaborativesession (for instance if the network becomes congested),the current system does not have a way to react to thechange. We thus plan to explore how to add dynamicmonitoring and adaptation under changing conditions.

In order to make the system adaptive, it is necessary tocollect, during the collaborative session, the samestatistics that are collected during the benchmarks, that is:frame rate and percentage of dropped messages. If thepercentage of dropped messages exceeds the upperbound, the current solution is temporarily marked asinvalid. In this case, the optimizer module has to beinvoked in order to look for a new solution. Since theoptimizer module uses the whole search space as input,

the statistics collected during the benchmark have to beextrapolated based on the current statistics collectedduring the collaborative session. We are currentlyexperimenting with different formulations for thisextrapolation.

AcknowledgementsThe work presented in this paper was sponsored by

Eafit University, NSF Contract No. ANI-01-23910 andthe Rutgers CAIP Center. The authors are grateful toProfessor Manish Parashar, from Rutgers University, forhis ideas and comments on how to make the modeladaptive.

References

[1] Capps, M.V. Fidelity Optimization in Distributed VirtualEnvironments. Ph.D. thesis, Naval Postgraduate School,Monterey, CA 2000.

[2] Faisstnauer, C., D. Schmalstieg and W. Purgathofer.“Priority Round-Robin Scheduling for Very Large VirtualEnvironments”. Proceedings of IEEE VR 2000, pp. 135 – 142.

[3] Greenhalgh, C., S. Benford and G. Reynard. “A QoSArchitecture for Collaborative Virtual Environments”. InProceedings of ACM Multimedia 1999, pp. 121 – 130.

[4] Macedonia M.R. and M. Zyda. “Taxonomy for NetworkedVirtual Environments”, IEEE Multimedia, 1997, pp. 48-56.

[5] Macedonia M.R. A Network Software Architecture forLarge-Scale Virtual Environments. Ph.D. thesis, NavalPostgraduate School, Monterey, CA 1995.

[6] Singhal, S. and M. Zyda, Networked Virtual Environments,ACM Press, New York, 1999.

[7] Sowizral, H., K. Rushforth and M. Deering. The Java 3DAPI Specification. Java Series. Addison-Wesley, December1997.

[8] Terrence F. and P. Dew. “A Distributed VirtualEnvironment for Collaborative Engineering”. In Presence, Vol7, No 3, June 1998, pp 241 – 161. [9] Trefftz H. and I. Marsic. “Message Caching for Global andLocal Resource Optimization in Shared Virtual Environments”.Proceedings of VRST 2000, pp. 97 – 102.

BachueBochica

M orlak

No S.A.

S.A.0

1

2

3

4

Frame Rate Increase (%)

No S.A.

S.A.

Figure 8. Increase in Frame Rate in the presence of theSwitchboard Architecture and the solutions described intable 2.