libcppsim: A SIMULA-LIKE, PORTABLE PROCESS-ORIENTED SIMULATION LIBRARY IN C++
Moreno Marzolla Dipartimento di Informatica Universita` Ca’ Foscari di Venezia via Torino 155, 30172 Mestre (VE), Italy e-mail: [email protected]
KEYWORDS Process-Oriented Simulation, Simu- vided as libraries which can be linked to user’s applica- lation Library, C++. tions. Examples of simulation libraries based on general- purpose languages include CSIM19 [Schwetman, 2001] and C-Sim [Hlavieka` et al., 1999] (based on the C ABSTRACT language), C++Sim [Little and McCue, 1993], OM- NET++ [Varga, 2001] and DESP-C++ [Darmont, 2000] In this paper we describe the design and implementa- (based on the C++ language) and JavaSim [Little, Little] libcppsim tion of , a general-purpose, process-oriented (written in Java). More sophisticated and user-friendly libcppsim simulation library written in C++. provides simulation tools have also been developed to make the a set of classes for implementing simulation processes, implementation of simulation models easier for non- scheduling primitives, random variate generation and out- programmers. Such simulation environments are usu- put data analysis functions. The main simulation entity ally limited to particular models, such as those based on provided by the library is the simulation process; the ba- Queuing Networks or Petri Nets; they provide users with sic process scheduling primitives are modeled upon those visual editors for graphically building the model. provided by SIMULA’s simulation class. The modular Simulation languages and libraries can be based on object-oriented design of libcppsim allows users to an event-oriented or process-oriented paradigm. Event- extend its functionalities with minimal effort. In order oriented simulation models are described in term of the to improve efficiency, simulation processes are not im- events which can change the system’s state. A process- plemented as operating system threads; instead, we use oriented simulation model is represented as a collection coroutine objects which implements a cooperative quasi- of concurrently executing simulation processes, each one parallel process environment. A portable implementation with its own thread of execution. A simulation process is of coroutines is provided in order to allow libcppsim made of two parts: a set of local variables, and a sequence to be used on different platforms. of actions to execute. It should be noted that many existing simulation lan- 1 INTRODUCTION guages and tools suffer either a long learning time, poor performances, or can only be used for special-purpose Simulation is a general modeling technique which can be models as they lack generality. Simulation libraries based used for analyzing systems which can not be described on the event-oriented paradigm, while usually easier to and evaluated analytically. Many tools and languages learn, are not suited for models with a high number of dif- have been developed in order to facilitate the implementa- ferent event types, as the resulting simulation programs tion of simulation models. SIMULA [Dahl and Nygaard, would be very difficult to understand and debug. On 1966] has been one of the first successful general-purpose the other hand, implementing the process-oriented sim- programming languages providing special features tar- ulation paradigm on the top of a conventional, general- geted at simulation implementation purposes. SIMULA purpose programming language can be difficult due to provides a set of basic facilities for describing a simula- limitations (the main being the lack of support for corou- tion model as a set of cooperating simulation processes tines) of the host language. Nevertheless, using a stan- executing in a quasi-parallel system. These facilities al- dard programming language is desirable because model- low the description of many typical simulation models, ers are more likely to be already acquainted with it and and could also be used as building blocks for more so- do not require to learn some new idiom. phisticated applications; DEMOS [Birtwistle, 1979] was In this paper we describe libcppsim, a process- one of the alternative simulation systems developed in oriented, discrete simulation library written in C++. SIMULA. Our goal is to provide a simulation library based on a Traditional general-purpose programming languages widely used and efficient object-oriented programming can be used for implementing simulation programs as language. Object-orientation has long been recognized well. Support for simulation facilities is usually pro- to be very useful for modeling complex systems; it is not a surprise that SIMULA was one of the first object- the stack of all the routines whose activation records are oriented programming languages. libcppsim imple- not on at the topmost position. ments a limited set of simulation primitives which can be This problem can be solved in different ways. The learned quickly and can be immediately used for imple- first approach is based on the “copy-stack implementa- menting simulation models. The provided general frame- tion” described by Helsgaun [Helsgaun, 1999]. The stack work can be extended if necessary with more complex, of the currently operating coroutine is kept in the C++ high-level functionalities. runtime stack. When a coroutine suspends, the runtime Efficiency was one of our main concerns. For that rea- stack is copied in a buffer associated with the coroutine. son the pseudo-parallel simulation process system is not The buffer is allocated in the dynamic heap, so it does not based on the threading model of the underlying Operating interfere with the normal stack operation. A coroutine System (OS). Threads are not handled efficiently in ev- is resumed by copying the content of that buffer back to ery OS, as thread switching may incur in the same over- C++’s runtime stack and setting the program counter to head as process switching. Moreover, complex simula- the saved execution location. tion models made of tens or thousands of simulation pro- A second approach consists of making use of the con- cesses would probably overflow the resources (process or text handling facilities provided by most Unix SysV-like thread table size) of many operating systems. We address environments. The OS provides functions allowing user- this problem by implementing the coroutine primitive as level context switching between different threads of con- a C++ class. Coroutines implements a simple, user-level trol within a process using the getcontext(), setcontext() cooperative multitasking environment; while this lacks and makecontext() functions. In this approach each the features of multitasking, it is exactly what is needed coroutine has its own run-time stack in a pre-allocated to implement process-oriented simulations. block in the heap. This paper is organized as follows. Section 2 de- Both approaches have advantages and disadvantages. scribes how coroutines and simulation processes are im- The “copy-stack” approach is the most portable, as it can plemented in libcppsim, and the process scheduling be implemented in every modern OS which implements facilities are illustrated in Section 3. Random variate gen- the setjmp() and longjmp() system calls (almost every- eration is described in Section 4 and output data analysis one does). However, it requires a copy of the C++ run- in Section 5. In Section 6 we show a usage example of time stack to be saved and restored every time a coroutine the library, and conclusions are reported in Section 7. passes control, which may cause a considerable overhead. On the other hand, the approach based on the context han- 2 SIMULATION PROCESSES dling facilities is simpler to use and more efficient, as the stack content is not copied. This approach is, however, Coroutines [Marlin, 1980] are a programming construct less portable as not every OS implements the required which can be useful for implementing process-oriented system calls. Also, the context-based approach does not simulation languages and libraries. Coroutines are blocks allow the coroutine context to grow past the dimension of code with associated state. A coroutine can suspend defined when the context is allocated. The user is re- itself by calling another coroutine; however, unlike tra- quired to set the maximum dimension of the context in ditional subroutine call in which the caller is suspended advance; choosing a too small buffer results in erroneous until the callee terminates, coroutines may be reactivated runtime behaviors caused by stack corruption which can in any order. be difficult to debug. A complete discussion is given SIMULA has coroutines as a built-in facility; unfortu- in [Helsgaun, 1999], and detailed portability considera- nately, the C and C++ programming languages, which are tions of different context manipulation strategies are de- widely used and for which efficient compilers are avail- scribed in [Engelschall, 2000]. able, do not provide coroutines natively. The libcppsim library implements both stack- In C/C++, each function is associated to a data struc- handling mechanisms, and the user can choose which one ture called activation record which is stored in the run- to use at compile time. As a general rule, the “copy- time (LIFO) stack. The activation record contains infor- stack” variant is useful when developing the simulation mations about the state of the routine, such as the value of program, as stack corruption errors do not occur and it is local variables and the return address used to resume the possible to measure the maximum stack size required by execution after a function call. When a function call oc- the application; then, when the program is verified, pro- curs, a new activation record is created and put on the top duction runs may be done with the more efficient context- of the stack. All variables locally defined by the called based approach. routine are stored on the newly created activation record. Once coroutines are available, it is easy to define sim- When a routine terminates, its activation record is pushed ulation processes on top of them. Fig. 1 shows the class from the stack. LIFO handling of the activation records hierarchy related to simulation process implementation. does not work anymore with coroutines, because the cur- A simulation process is represented by the process class, rently active coroutine may not be the one associated with and is derived from the coroutine class; a simulation pro- the topmost activation record in the stack. This implies cess is a coroutine whose state must be preserved across that the order of activation of coroutines is not given by invocations. the LIFO stack handling. Also, it is not possible to grow Each simulation process has a unique identifier and a shared process coroutine -_sharedCount: int +call() -_id: int +resume() #getRef(): int -_name: string #unGetRef(): int +terminated(): bool +activate() _obj #detach() +activateAfter(p:handle_p) #main() +activateBefore(p:handle_p) -enter() T +activateAt(t:double) +activateDelay(t:double) _sqs handle +reactivate() sqs +operator ->(): T* +reactivateAfter(p:handle_p) +insertAt(p:handle_p,t:double): absEvNotice* +operator (): T* +reactivateBefore(p:handle_p) +insert(p:handle_p,q:handle_p): absEvNotice* +rep(): T* +reactivateAt(t:double) +remove(ev:absEvNotice*) +isNull(): bool +reactivateDelay(t:double) +clear() +setNull() +cancel() +first(): absEvNotice* +idle(): bool +empty(): bool +terminated(): bool +size(): int +evTime(): double #passivate() #hold(t:double) _ev absEvNotice #end_simulation() _proc #inner_body() #_time: double
Figure 1: libcppsim Process Class Diagram user-defined name. The process class has methods pro- the logarithm of the SQS size. More efficient data struc- viding SIMULA-like scheduling primitives: it is possible tures (e.g. calendar queues [Brown, 1988]) can be imple- to suspend the current process for a given amount of time, mented by supplying a corresponding class, without other schedule the activation of another process in the future or modifications being required. cancel a pending process from the sequencing set. The actions performed by a simulation process are specified by defining the pure virtual method inner body(). Fig. 2 4 RANDOM VARIATE GENERATION shows the C++ interface of the process class. Simulation programs require an efficient and statisti- The handlehTi class implements a “smart pointer” to cally robust mechanism for producing streams of pseudo- an object of type T , where the class T must inherit from random numbers with given distribution. libcppsim class shared. A smart pointer [Stroustrup, 1997] is a defines an abstract templated class rnghTi representing pointer to an object which keeps count of the number a pseudo-random number generator of numbers of type of times the object is referenced. When the last smart T . It is possible to generate streams of random integers, pointer is deallocated, the referenced object is automati- real or boolean values, by setting T to the appropriate cally destroyed. Smart pointers are used for implement- datatype in a subclass. ing a garbage collection mechanism. Our implementa- It turns out that the basic ingredient for generating tion of the handle class differs from the one proposed stream of pseudo-random numbers is a good uniform in [Stroustrup, 1997] as we store the reference count in generator RN(0, 1) over the interval [0..1]. We chose the object rather than in the handle. This allows to pre- algorithm MRG32k3a from [L’Ecuyer, 1999], which is serve the counter even if the handle is converted to a C- known to have long period and good statistical properties. style pointer and then back to an handle. We implemented different random variate generators us- ing algorithms described in [Banks, 1998, Ch. 5]. These 3 THE SEQUENCING SET generators include the Uniform, Exponential, Gamma, Weibull, (Truncated) Normal, Bernoulli and Empirical distributions. The Sequencing Set (SQS) is a data structure containing the list of simulation processes to be executed; the list is sorted by nondecreasing activation time order. Each sim- 5 OUTPUT DATA ANALYSIS ulation process contained in the SQS is associated with an event notice. The event notice basically contains the sim- Simulation results are sequences of observations for ulated timestamp at which the process is to be resumed, quantities of interest. Appropriate statistical techniques and references to that process. Additional informations should be applied to analyze these sequences, as the ob- may be present in order to make insertion or removal of servations are in general autocorrelated. libcppsim event notices more efficient. implements a set of classes dealing with collection of libcppsim provides two different implementations statistics; the relevant portion of the class diagram is of the SQS data structure. The first is defined in class shown in Fig. 3. sqsDll, and is based on a doubly linked list of event no- All types of statistical variables inherit from the tices. This data structure is very simple to implement, varhTin, Touti abstract base class. This class represents but insertions of event notices require linear time on av- “variables” which can be updated many times by feed- erage to be performed. A more efficient implementation ing values of type Tin, and compute some function from is given by class sqsPrio, based on balanced search trees. the input data producing a result of type Tout. Each vari- The expected insertion time in this case is proportional to able has two pure virtual methods: update() and reset(). T_in T_out var #_name: string #_numUpdates: int #_numResets: int confInt +update(v:T_in) +_lBound: double +reset() +_uBound: double +value(): T_out +_confl: double +report()
T_in:double T_in:double T_in:double T_out:confInt T_out:vector
trremoval_frac trremoval_const mean repmean welch #_frac: double #_l: int accum bmeans histogram
Figure 3: libcppsim Statistics Class Diagram
These are used to insert a new value and reset the variable and then treating the means of these batches as to a known state. The result can be computed by invok- if they were independent to compute the sample ing the value() method. Variables are not stateless; thus, mean [Banks et al., 2001]. it is possible that successive repeated invocations of the value() method return different results. This is useful for welch This class implements the graphical procedure representing a random stream as a variable which is ini- of Welch [Welch, 1983] for identifying the length tially updated with the seed of the pseudo-random num- of the initial warm-up period. Values from R in- ber generator, and whose value() method returns the next dependent replications are collected. The values pseudo-random number from the stream, at the same time across different replications are first averaged and updating the seeds. Class var defines also a pure abstract then smoothed by computing moving averages. The report() method which can be used to display a report plot of the moving average becomes approximately about the content of the class. constant after the warm-up period is over. The statistics class represents a base class for a number of predefined statistic functions. In addition to the meth- histogram This class computes an histogram profile ods and attributes defined in its parent class var, statistics from a sequence of values. The user supplies an contains an attribute representing the confidence level of expected lower bound and upper bound for the ob- the computed result. Statistics are special kind of vari- served values, and the number of cells (bins) in ables returning objects of type confInt (confidence inter- which the histogram will be divided. vals). The following statistics can be computed: The trremoval class is used to model algorithms used mean This class is used to compute a confidence interval for removing the initialization bias from a sequence of for the mean of a sequence of statistically uncorre- observations. The simulation run produces the sequence lated observations. of observations Y1,Y2,...Yn for some parameter of in- accum This class is used to compute the time-weighted terest. Using the whole sequence to compute the statis- sum of observations Y1,Y2,...Yn, n > 1 with tics is often dangerous, as there is a bias associated to timestamps respectively t1, t2, . . . tn. The result is artificial or arbitrary initial conditions. One method to Pn−1 A = i=1 Yi(ti+1 − ti) overcome this limitation is to divide the sequence of ob- servations into two phases: an initialization phase which repmean Computes the mean of a sequence of observa- includes observations Y ,Y ,...Y , followed by a data- tions using the method of independent replications. 1 2 d collection phase Y ,Y ...Y . Observations from The simulation must be repeated R times, each run d+1 d+2 n the initialization phase are discarded, and only those in using different random streams and independently the data-collection phase are used for computing the re- chosen initial conditions. Averages across replica- quired statistics. The parameter d, 0 < d n is called tions can be used to obtain an accurate estimator of truncation point. the sample mean [Banks, 1998]. Classes inheriting from trremoval are used to estimate bmeans The method of batch means divides the output the truncation point d. Currently, there is no automatic, data from one replication into a number of batches, general and correct method for detecting the length of the typedef handle
Brown, R. (1988, October). Calendar queues: A fast 0(1) White Jr., K. P., M. J. Cobb, and S. C. Spratt (2000). priority queue implementation for the simulation event A comparison of five steady-state truncation heuristics set problem. Comm. of the ACM 31(10), 1220–1227. for simulation. In Proc. 32nd Winter Simulation Con- ference, Orlando, FL, pp. 755–760. SCS International. Dahl, O.-J. and K. Nygaard (1966, September). SIMULA–an ALGOL-based simulation language. Comm. of the ACM 9(9), 671–678. AUTHOR BIOGRAPHY Darmont, J. (2000, January). DESP-C++: a discrete- event simulation package for C++. Software–Practice MORENO MARZOLLA received MSc and PhD degrees in and Experience 30(1), 37–60. Computer Science in 1998 and 2004 respectively, both from “Ca’ Foscari” University of Venice. From 1999 to 2001 he was Engelschall, R. S. (2000, June 18–23). Portable a software engineer at the italian National Institute for Nuclear multithreading–the signal stack trick for user-space Physics. He currently holds a post-doc position at the Univer- thread creation. In Proc. USENIX Ann. Tech. Confer- sity of Venice. His research interests include performance eval- ence, San Diego, CA. uation of software systems, distributed systems monitoring and parallel and distributed simulation. Helsgaun, K. (1999). A portable C++ library for corou- tine sequencing. Datalogiske Skrifter (Writings on Computer Science) 87, Roskilde University, Denmark.