Parallel Computing 19 (1993) 219-228 219 North-Holland

PARCO 747

Short communication

Parallel trace-driven simulation for packet loss in finite-buffered voice multiplexers

Yi-Bing Lin Bell Communications Research, Rm 2D297, 445 South Street, Morristown, NJ 07962-1910, USA

Received 6 January 1992 Revised 28 May 1992, 13 August 1992

Abstract

Lin, Y.-B., Parallel trace-driven simulation for packet loss in finite-buffered voice multiplexers, Parallel Computing 19 (1993) 219-228.

Packet loss of voice multiplexers is usually studied by a G / D / 1 / K system. Most analytic analyses concentrate on modeling the input process to the multiplexer. Sometimes, it is necessary to study the behavior of the multiplexer under real workload. A trace of packet arrivals is used as the input to the simulation model. The trace is usually huge, and the time to complete the simulation is very long. To speed up the simulation process, this paper proposes a parallel simulation algorithm. We show that the speedup of our approach is O(N) where N is the number of processors. The algorithm can also be used for trace-driven simulation of any system modeled as a G / D / 1 / K queue.

Keywords. Discrete event simulation; G / D / 1 / K queue; parallel simulation; trace-driven simulation; voice packet-switched network.

1. Introduction

Voice traffic was usually handled by circuit switching. Recently, packet-switched communi- cations networks have been developed for voice and data, with a single fast channel handling the packets from all sources. A packet voice network is delay sensitive. It is necessary to keep transmission delay of a voice packet within some reasonable bound and drop the packet if it does not receive service within this time-out period. Thus, packet loss probability is usually used to evaluate a voice transmission system. In the performance study of voice packet multiplexers, if the packets are assumed to be of fixed length, and the service at the multiplexer is FCFS (first come first serve), then the delay bound of packets can be addressed

Correspondence to: Y.B. Lin, Bell Communications Research, Rm 2D297, 445 South Street, Morristown, NJ 07962-1910, USA, email: liny@thumper.bellcore.com

0167-8191/93/$06.00 © 1993 - Elsevier Science Publishers B.V. All rights reserved

220 Y.-B. Lin

by a queue of finite-buffered capacity. Thus, the behavior of the multiplexer can be studied via a G / D / 1 / K system.

Several analytic approaches have been proposed to model packet loss in finite-buffered voice multiplexers (see [11] and references therein). The key issue is to model the input process to the multiplexer. Several techniques for modeling the superposition of the voice sources (such as Markov modulated Poisson process, fluid flow approximation, and so on) have been proposed.

In many cases, it is desired to study packet loss in finite-buffered voice multiplexer based on real workload. In such a case, the real packet arrivals to a multiplexer are recorded in a trace. Then a simulation of finite-buffered queue is conducted by taking the trace as input. This is called trace-driven simulation. The input trace is usually huge, and the time to complete the simulation is quite long (several hours to several days). Thus, it is important to speed up the simulation process.

This paper proposes a parallel trace-driven simulation algorithm for finite-buffered multi- plexer. We show that the speedup of our algorithm is O(N), where N is the number of processors. The algorithm can also be used to simulate any system that is modeled as a G / D / 1 / K queue. Section 2 describes time-division parallel simulation, an approach to parallelize the discrete event simulation. Based on the time-division approach, Section 3 presents and analyzes a new parallel algorithm for trace-driven simulation of finite-buffered voice multiplexers (a G / D / 1 / K system).

2. Time-division parallel simulation

Most parallel discrete event simulation approaches [1,2,5,7,8,10,12] follow two sequential constraints: (1) If two events are scheduled for the same process, then the event with smaller timestamp

must be executed before the one with larger timestamp. (2) If an event executed at a process results in the scheduling of another event at a different

process, then the former must be executed before the latter. Another approach has been proposed to relieve the sequential constraints [9]. In this

approach, the simulation model is partitioned in the simulation time domain. The details of the time-division approach are given below:

Phase 1. Partition a simulated time interval 1 into N sub-intervals. A processor is assigned to simulate each sub-interval. For each sub-interval, 'guess' an initial state, then start the simulation.

Phase 2. When the simulation of each sub-interval completes, a 'fix up' is performed to ensure that the final state of the ith sub-interval matches the initial state of i + 1st sub-interval. 2

Examples of this approach are the parallel G / G / 1 queue simulation proposed by Green- berg et al. [3] and the parallel trace-driven cache simulation proposed by Heidelberger and Stone [4]. We use the later to illustrate the idea of the time-division approach. In Heidel- berger and Stone's algorithm for parallel trace-driven simulation of uniprocessor cache bahvior, an input trace is partitioned into N sequential subtraces, where N is the number of

1 In a trace-driven simualtion, the simulated time interval is represented by an input trace. 2 Note that the algorithm described in Section 3 allows certain degree of inaccuracy, and exact state match is not

required.

Parallel trace-driven simulation for packet loss 221

processors. Each subtrace is analyzed on a separate processor. Each processor initializes its

cache contents in two ways: (a) The cache is empty, and the first reference to a location is a miss. (b) The cache is full, and the first reference to a location is a hit.

Each processor simulates its input subtrace with the initial cache contents and produces a count of the number of misses. At the end of the simulation, the sum of the misses counted in each processor is an u p p e r / l o w e r bound of the true misses if (a ) / (b ) is used for initialization. If the upper and lower bounds are not tight enough, we may need a fixing phase to find the correct count. The idea is based on the fact that for every subtrace, the initial cache contents only have transient effects. Thus, the initial contents of the cache become less relevant (and eventually irrelevant) as new references occur. The true initial cache contents of subtrace i can be obtained from the final cache contents of subtrace i - 1 in the first simulation phase. Thus, correct simulation can be obtained by re-simulating a subtrace with the true initial cache contents until the initial effect disappears.

The algorithm described in the next section (cf. Fig. 4) follows the time-division approach. Similar to Heidelberger and Stone's algorithm, we partition the input trace into N subtraces. For each subtrace, we simulate the behavior of a finite-buffered queue assuming that the queue length is empty at the beginning (this is referred to as Case I simulation in the next section). In Phase 2, the number of lost packets is re-computed to reflect the correct initial condition (i.e. the initial queue length). Phase 2 of our algorithm is very different from that of Heidelberger and Stone's algorithm.

3. Approximations for trace-driven G / D / 1 / K queue simulation

Suppose that there are N processors, and the input trace is divided into N subtraces where every subtrace has n entries (packet arrivals). The ith subtrace is {el, ~ [1 _<j < n} where el, i represents the [(i - 1)n + j ] t h packet arrival to the multiplexer occurring at time r(eio). Let K be the buffer size of the multiplexer and d be the constant service time. Consider three cases of simulation.

Case I. Simulate the behavior of the multiplexer with subtrace i assuming that the queue is empty at r( e i_ t,n) (by convention, r( eo, ~) = 0).

Case II. Simulate the behavior of the multiplexer with subtrace i where the queue length at r(ei_l , n) is obtained from the simulation of subtrace i - 1 and assume that the residual service time of the packet being processed at r(e i_ 1,~) is d.

Case IlL Simulate the behavior of the multiplexer with subtrace i. Both the queue length and the residual service time of the packet being processed at r(e i_ 1,,) are obtained from the simulation of subtrace i - 1.

Case I I I produces the exact number of lost packets for the simulation. Case I produces a lower bound for the number of lost packets, and Case II produces an upper bound for the number of lost packets. In parallel simulation using the time-division approach, Case I simulation is performed in Phase 1, and the results for Case II are obtained in Phase 2. The discussion in this section shows how to obtain the output measures for Case II from the measures of Case I.

Consider Case I. Let b(°)(r) be the queue length at time r and b}.°m ) be the queue length w h e n el, m arrives. That is, b}°m ) = b(°)('r(ei m))" In Fig. 1, 3 we have b}~ ~ = 1, b}.°2 ) = 2, b}°2, = 2, and so on. In this example, b~,~ ) = b} °) because el3 departs at r(e i 5). '

3 For illustration purpose, all packets a r r ive /depar t at integer clock ticks in Figs 1-3. In our algorithm, a packet may a r r ive /depar t at arbitrary time.

222 Y.-B. L/n

e l , 3

b(6) O -) e l , 1

~ i , 2

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

C iT1 ]

'~- idle- -~,~ i~--, idle- --',, I

i l i

el ,4

_ ei ,5 e i , n - 1

! i ,6 | ' , , - . . . . . . . . . . . . . . . . . L-t I I

r ( t i m e )

Fig. 1. The histogram of b(°)(z) (K = 4),

The multiplexer is either idle or busy. In Fig. 1, the histogram of b<°)(~ -) is the alternations of idle and busy periods. Denote a busy period in Case I as a cluster . Let Ci, j be the set of packets arriving in the j th cluster• Suppose that there are J clusters in the Case I simulation of subtrace i 4. In Fig. 1, Ci, 1 = {ei,1, el,2} , Ci, 2 = {el,3, ei,4, el,5, ei,6} , and the last cluster Ci, J = { e i , n_ l , el,n}. L e t ei,mj be the first packet that arrives in the j'th cluster. In Fig. 1, m I = l, m 2 = 3, and m g = n - 1.

Let I/~°) be the idle t ime of the multiplexer before z(ei ,mj) . We have

Ii~°,1 ) = "c( ei,1) - ~'( e i _ l , n ) - d .

The idle periods in Case I can be used to handle extra packets. Let A i j be the maximum number of extra packets that can be handled by the multiplexer before ~'(ei,mi) in Case I. Since the packet processing time is a constant d, we have

The number of extra packets that can be handled by the multiplexer in the j th idle period is

Let LO) be the number of packets lost in the first j clusters in Case I. l,]

Now we define notation for Case II. Note that the term 'cluster ' is still used in Case II, but it does not represent the busy period between two idle periods in Case I. For example, the beginning of the j th cluster in Case II simply means the time when the packet e i m. arrives at the multxplexer. We note that !mmedlately before ~-(e im.), the multiplexer may stdl be busy in

• . ~ 3. • Case II. Let Li, j be number of packets lost m the first J clusters in Case II, and let

li, / = L i j - L~°~, and i i , /= l i , / - l i j - 1.

By convention, li, o = O. Let b(~') be the queue length at time ~- and bi, m be the queue length after ei,,~, where

1 < m < n, arrives in Case II (include ei,m). Thus, bi, m = b(z(e i , ,~)) . F igure 2 shows an example of b ( r ) ' s histogram. Let

[~ i , j : bi,m/ - b~°) t , m j "

4 If more than one subtraces are referred to, Ji is used to represent the number of clusters in the ith subtrace.

Parallel trace-driven simulation for packet loss 223

b(°)(r) 6 F . . . . . . ~, b ( ~ ) . . . . . .

, j j t. . . . . . . . . -I f-- .I-I t. . . . . .

1 Ci ,j [ I I ,4~ I rh l ,.I., I rh I ,,k I rh I n~ I rJn , i i

~6..~'~ d -' r (time) 1.3

Fig. 2. The h i s tog rams for b ( r ) and b(°)(r) (d = 4, and ~i,j = 2). A squa re r ep re sen t s the d e p a r t u r e of a packe t in Case I. A circle r ep re sen t s te d e p a r t u r e of a packe t in Case II .

In Fig. 2, /3i, s = 3. Let ~,j be the residual service time of the packet being processed at . r (e i ms) assuming that/3i, s > 0. In Fig. 2, tSi y = 2. When fli,j > 0, it implies that the multiplexer is busy in the period [r(e i_ Ln)' r(ei,m,)]" T'laus,

T ( e i ,m j ) - - T ( e i - l ,n ) I

ai'J = [ r(ei'ms) - r ( e i - l ' n ) ] - d [ = I ( ° ) - A i ,

Since the packets are indistinguishable, both FCFS and LCFS (last come first serve) schedul- ing policies result in the same departure process and the number of lost packets [6]. (However, the distributions of waiting time are very different for these two policies.) Under the LCFS policy, the way of handling (either execute or drop) packets in Cio in Case II is almost identical to that in Case I. In Case II, at r(e i ,, ), no packets in the queue except for , j the one being processed will be served before all packets in Ci, j are handled. Thus, the number of extra lost packets li, j is contributed by the packets in the queue a t r(e i_ 1,n)" For illustration and proof purpose, we consider a variation of LCFS policy for Case II. The behavior (in terms of queue length and packet lost) under this policy is identical to the FCFS policy: If/3i, s > 0 when ei,mj arrives, then the packet currently being served is interrupted and placed back to the queue. The multiplexer processes e i m, with service time 6/,i" If the

. . ~ s r interrupted packet is executed again, its service time is d. In othe word, this policy switches the identities of e i m and the packet being executed at "r(e i m )" In the modified LCFS policy, at r(e i m ), no pacl~e~s in the queue will be served before all p~ckets in C i j are handled (either execute~ or lost). Since the packets are indistinguishable, it is clear that tlae departure process (and the number of lost packets) under this policy will be the same as that under FCFS policy. Also, the notations defined above are not affected by this policy. From now on, we assume the variation of LCFS policy for the finite-buffered queue simulation. (For Case I, the variation is exactly the same as the LCFS policy because the queue is always empty when e i m arrives.) . ' / Suppose that el, m E Ci, j. Let Bi, j be the maximum number of extra packets (besides those in Ci,s.) that can be buffered in the j th cluster in Case II without being dropped. Then we have

l i , j = m a x ( f l i , j -- n i , j , 0 ) . ( 1 )

Suppose that ei, m ~ Ci, j . Let b(r) be the number of packets in Ci , j , which are also in the queue at r (where time r is in Ci, j a n d ~)i,m = b(T(ei,m)))" Then

Bi, j = K - max bi,m. el, m E C i, j

For all ei, m ~ Ci , j , bi,m can be obtained from bi, m by 'shifting left' the departure process of the j th cluster in Case I by the amount $i,j (cf. Fig. 3). The 'shifted process' is the departure process for Case II (cf. Fig. 3(b)). Note that if K = 0% we have bi, m = f l i , j + b i , m (cf. the historgrams of b(r) and b(r) in Fig. 3(c)).

224 Y.-B. Lin

6

5

4

3

2

1

6

5

4 3

2

1

(a) The arrival process in the ]th cluster (for both Cases I and II)

? _ S I I I I I I I I I I I I I I I I

I I '" the ]th cluster *' ~" (time)

( b ) The d e p a r t u r e p r o c e s s i n t h e ] t h c l u s t e r

_ _ Case I

...... Case II

I I I I I I 1 I I I I I I I = i i i I

I'~ 6 : ' ~ d " ' ' (ti ) i j ', ~- m e ,4 t h e j t h c lu s t e r *'

(c) The queue length in the ]th c l u s t . e . r . . . b ( r )

b(°)(r) . . . . . . . . . . . . . . . . . . . . b ( ~ ' )

. . . . . . . . .

L . . . . I L . . . . I

, , , , , , , , i , 1 ~ i m ' . the jth cluster "' r (time)

Fig. 3. The histograms for b(~-), b(°)(r), and b(~') (d = 4, and ~i,j = 2).

From Lemmas 1 and 2 in Appendix B, we have

[~i,j = max(bi- 1,n -- li,j- 1 -- Z i , j , O)

and

l i j = m a x [ b i - l n - " " l<~k<jmin ( Z i , k W B i , k ) , O ] .

Based on the above two equations, we have (cf. Theorem 2 in Appendix B)

Li j -L(° ) , -- i,J +max[b /_ X n--, l<_j<jmin (Zi , j+Bi j ) , , O]

bi, n = b!°,)~ + max(bi_ 1, . - l i , J - A i , j , O) in Case II simulation. Based on these equations, the parallel algorithm for Case II simulation is described in Fig. 4. Figure 5 illustrates the relationship among quantities computed in Steps 1 and 2 of the first three processors. An arrow from quantity x to quantity y means that the computation of y depends on x. The time complexity of Phase 1 is O(n). In Phase 2, every iteration takes constant time. Thus, the time complexity is O ( N - 1). Since n × N is very large, the time complexity is dominated by Phase 1, and the speedup of the parallel simulation is O ( N ) .

Parallel trace-driven simulation for packet loss 225

P h a s e 1. Perform Case I simulation and compute r(°) b (°) Ai , j , and X i ~i,d~ i,nl

mill (Ai j + Bi, j) . l<j<J '

~(0) Compute Li,j and bi,,~ (cf., P h a s e 2. Iterate on i from 2 to N. Let bl,n = Vl, n.

L (°) b (°) Ai j and X i computed in Phase 1, and bi-x,n Theorem 2) based on i,J, i . . . . computed in the previous iteration of Phase 2.

Fig. 4. The parallel algorithm for Case II simulation.

As we mentioned before, the packet loss obtained from Case II is an upper bound. We need to show how accurate the bound is. Consider the simulation of subtrace i. Let L* and L i = Li, J be the number of lost packets in Case III and Case II, respectively. In Case II, we assume that the residual service time of the packet being processed at r(ei_l , n) is d. This conservative assumption introduces extra work for the multiplexer. The extra work either

(i) is absorbed by the idle periods, (ii) results in a packet lost, or

(iii) increases the queue length by 1 at r(ei,n). Exactly one of the aforementioned conditions is true. Let b* be the queue length at ~'(ei, m) l,m

in Case III simulation. Since b 1 n = b* and L 1 = L~, by induction, , 1 , n

L*+b*,,,, < L i + b i , , , < L * + b * + ( i - 1 ) . _ , (2)

From (2), we have

Processor 1 Processor 2 Processor 3

11o -@ Q Q

X3 Step 1

Step 2

Fig. 5. The relationship among quantities computed in Steps 1 and 2 of the first three processors.

226 Y.-B. Lin

N , Theorem 1. "~"ifg"N 1L*i - < ~N= 1Zi _ < N - 1 + Y~.iffilLi .

Theorem 1 indicates the accuracy of the upper bound for packet losts obtained in Case II. Since the input trace is very large, we expect that "-'i=rU 1L*i >> N - 1, and E~=lLi_ = ~=1 L*.

4. Concluding remarks

We have proposed a parallel trace-driven simulation for packet loss in finite-buffered voice multiplexers. With N processors, we showed that the speedup of our approach is O(N). The total number of lost packets obtained from the parallel simulation is an approximation. We

N * ]~N L* is the exact number of lost showed that ENi=IL*i -- < y-N=lL i < N - 1 + El= 1Li , where i= 1 i packets. In practice, y-N~=IL.~ >> N - 1, and the approximation is very accurate. Our technqiue can be used for trace-driven simulation of any system modeled as a G / D / 1 / K queue. One direction of our future research is to extend this algorithm for G / G / N / K queue simulation.

Appendix A: Notation

This section serves as an index to the notation used in this paper. Ai , j

ai,j

Bi j

b(.°? l , J

b(°)O -) bij

b(r) b

i , m

[~i,j Cij d 8i d

ei,j ei,mj #o, J, Ji K

L i j a? Li li,j, ii,j N

the maximum number of extra packets that can be handled by the multiplexer before "l'(e i m ) in Case I , j the number of extra packets that can be handled by the multiplexer in the j th idle period in Case I the maximum number of extra packets (besides those in Ci, j) that can be buffered in the j th dus ter in Case II without being dropped the queue length when el, j arrives in Case I

the queue length at time ~- in Case I the queue length after ei j , where 1 < j < n, arrives in subtrace i in Case II (include ei,j) the queue length at time ~- in Case II the number of packets in Ci,j, which are also in the queue at ~-(ei, m) in Case II

the number of packets in Ci,j, which are also in the queue at ~- in Case II ~i,j = bi,m - b~i°)m~ the set oi ~ packets arriving in the j th cluster of subtrace i in Case I the packet process time of the multiplexer the residual service time of the packet being processes at ~'(ei,m~) assuming that fli,j > 0 in Case II the j th packet arrival in the ith subtrace the first packet that arrives in the j th cluster in Case I

the idle time of the multiplexer before ~'(e i m ) in Case I . ° . ~ J

the number of clusters in the tth subtrace in Case I the buffer size of the multiplexer the number of packets lost in the first j clusters in Case I the number of packets lost in the first j clusters in the ith subtrace in Case II the number of lost packets in the ith subtrace in Case III L i = Li , J li, j = Li , j - Z~?), a n d ii, j = li, j - li, j _ 1. B y convention, li, o = 0 the number of processors

n

~'(ei,i) x,

Parallel trace-driven simulation for packet loss

the size of a subt race the (s imulat ion) t ime when ei,y arrives at the voice mul t ip lexer

X i = min t _<i _< j ( A i , j + Bi,j).

227

A p p e n d i x B: Proofs

This append ix proves the t h e o r e m used in Sect ion 3.

L e m m a 1. /3ij = max(b i_ l , n - li,j_ 1 - A i d , 0).

Proof. For j = 1, li, o = 0, and we have

ilia = m a x ( b i - l,n - aiA, O) = m a x ( bi_ l, n - li,j_ 1 - A iA , 0) .

For j > 1, the n u m b e r of extra 5 packets lost and the n u m b e r of extra packets handled by the mul t ip lexer dur ing [ ~( e i,m~_ l, "i'( e i,mi)] is no m o r e than i i, ~_ ~ + a i, j. Thus,

[ ~ i , j = max([~i,j_l - - l i , j - - 1 - - a i , j , O)

= m a x [ m a x ( [3i,j_2 - li,j_2 - a i , j - l , O) - l i , j - l - ai,j, O ]

= m a x [ f l i , j _ 2 - (li , j_2 W l i , j -1) - ( a i , j - l + a i , j ) , O]

l < k < _ j - 1 i <_k <<_j

= m a x ( b i _ l , n - li,j_ 1 - Z i , j , 0) . []

L e m m a 2. li, i = max[b/_1, n =- mini_< k_<j(Ai,k + B/,k), 0].

Proof. F r o m (1), the n u m b e r of extra packets lost in the j t h cluster is

l i , j = max(/3/,j -- Bid, O)

= max[max(h i_x , n - - l i , j - - Z i , j , O ) - n i , j , 0] ( F r o m L e m m a 1)

= max(b i_ 1, . - li, j - A i j - Bid, 0). (3)

F r o m (3) and since li,j = i~, i + l~, i_ 1, we have

li,j = m a x ( bi_ l, n - li,j_ l - A i d - n i , j , O) -F li,j_ 1

= max(b i_ l , ~ - A i , ~ - Bi,i, l i j - 1 )

= m a x [ maX ( b i - l ' n - h i j - B i ' j ) '

= m a x [ b i - l ' n - l_<k_<jmin ( A i , k + B i , k ) , O 1. []

T h e o r e m 2. In Case H s imulat ion, we have

L i l = g(°) + max[ 1 min<_y <-J ( A i d + Bi ' j ) 'O] (4)

bin -- b(°) + max ( bi - li J - Z i 1, O) (5) , - - i , n - - 1 , n , , "

5 The 'extra' packets means te packets in Case II but not in Case I.

228 Y.-B. Lin

Proof. Equation (4) is the direct consequence of Lemma 2. From I_emma 1 and because bi, n -b~°),,n = ~ i , ~ - ii,J, we have Equation (5). []

References

[1] K.M. Chandy and J. Misra, Distributed simulation: A case study in design and verification of distributed programs, IEEE Trans. Software Engrg. SE-5(5) (Sep. 1979) 440-452.

[2] R.M. Fujimoto, Parallel discrete event simulation, Commun. ACM 33 (10) (Oct. 1990) 31-53. [3] A.G. Greenberg, B. Lubachevsky and I. Mitrani, Algorithms for unboundedly parallel simulations, ACM Trans.

Comput. Syst. 9 (3) (Aug. 1991) 201-221. [4] P. Heidelberger and H.S. Stone, Parallel trace-driven cache simulation by time partitioning, Technical Report

RC-15500, IBM Research Division, T.J. Watson Research Center, Yorktown Heights, NY 10598, 1990. [5] D. Jefferson, Virtual time, ACM Trans. Programming Languages Syst. 7 (3) (Jul. 1985) 404-425. [6] L. Kleinrock, Queueing Systems: Volume H - Computer Applications (Wiley, New York, 1976). [7] Y.-B. Lin and E.D. Lazowska, Exploiting lookahead in parallel simulation, IEEE Trans. Parallel Distributed Syst.

1 (4) (Oct. 1990) 457-469. [8] Y.-B. Lin and E.D. Lazowska, A study of time warp rollback mechanisms, ACM Trans. Modeling Computer

Simulation 1 (1) (1991) 51-72. [9] Y.-B. Lin and E.D. Lazowska, A time-division algorithm for parallel simualtion, ACM Trans. Modeling Computer

Simulation 1 (1) (1991) 73-83, [10] J. Misra, Distributed discrete-event simualtion, Comput. Surveys 18 (1) (Mar. 1986) 39-65. [11] R. Nagarajan, J.F. Kurose and D. Towsley, Approximation techniques for computing packet loss in finite-buffered

voice multiplexers, IEEE J. Selected Areas in Commun. 9 (3) (Apr. 1991) 368-377. [12] R. Righter and J.C. Walrand, Distributed simulation of discrete event systems, Proc. IEEE 77 (1) (Jan. 1989)

99-133.