POKer, a Process-Interaction Simulator and Controller for use in Collaborative Simulation
Andriy Levytskyy, Eugene J.H. Kerckhoffs
Delft University of Technology Faculty of Information Technology and Systems Mediamatica Department Zuidplantsoen 4, 2628 BZ Delft, The Netherlands e-mail: [email protected]
and a subset of it, a process interaction world-view Keywords [20], which is of particular interest to us. This world- Discrete-Event simulation, Process-Interaction view gained its popularity due to the easiness of world-view, operational semantics, scripting mapping real-world processes into this formalism, languages, Python. and easiness of comprehending the essence of the process by a human. The above, as well as special application Abstract requirements for the simulation system we seek, In this paper we present the ideas and inspired us to develop our own special-purpose implementation of a small process-interaction kernel simulation software while trying to preserve its and cover its evolution from operational semantics connection to the formal background. In this paper of process-oriented simulation languages to the we present the ideas and implementation of a small current state of the kernel as (simulation) core of a process-interaction kernel and cover its evolution collaborative environment controller. from operational semantics of process oriented simulation languages to the current state of the kernel as (simulation) core of a collaborative 1. Introduction environment controller. Simulation as problem-solving methodology has been widely adopted in many practical domains. 2. View on the environment Users are free to select from a number of available general-purpose simulation software [14, 4] or, in 2.1. Functional overview case of special user requirements, a custom software In order to understand better the initial requirements system can be developed. The latter scenario has a for our custom system, we give a brief functional potential negative side effect: simulation often overview of the intended environment (for more becomes interpreted and applied by developers in a information, please see [9]). It is based on a three less formal way. As the result, it becomes more layer architecture: (i) front-end layer (high-level difficult to reason about properties of such front-ends), (ii) middle layer (environment simulation systems and prove their correctness. controller), and finally, (iii) back-end layer On the other hand, Simulation and Modelling formal (distributed heterogeneous hardware and software theory provides a reliable framework to support the resources). entire process of modelling and simulation [18]. The front layer consists of a number of client-side There exist formal works dedicated to the study of front-ends . They provide users with a high level simulation languages and simulators for some major GUI to the system (e.g., web-based interface), formalisms and world-views [2, 3, 2]. They provide enable them to operate in the environment, formally proven semantic backgrounds and accomplish background routine jobs necessary for implementation reference for development of execution of users’ activities, and finally, custom simulation systems. One of the widely used communicate with the middle layer. basic formalisms is the discrete event formalism, Requirements Property Description Handling external events Many software systems providing the process interaction world-view do not natively support external events. Scheduling mechanism should be aware of external and internal events, and as a result, properly schedule the involved event notices on the same EL. Support of both real-time and as- Transparently processing both types of processes (programs) soon-as-possible time regimes intermixed on the same EL. Adjustments in synchronization Connectivity to environment resources changes operational semantics mechanism of standard simulation synchronisation mechanism. Programming language Language constructs are needed to support mapping a sequence of user’s real-world activities into a process. Transparent support of different For users the most natural framework is process interaction. For the world-views simulator, which deals with resource-oriented scenarios, event scheduling is more proper. Freedom of customization We need powerful constructs to represent components of our system and freedom to adjust them easily for our needs. Unrestricted monitoring of the 3rd party systems are often ‘black boxes’ and it would be impossible or activities in the environment very difficult to make them provide all the time full overview on all that is happening in the environment. Easy integration with other Web, distributed objects, network programming, inter-process industry technologies communication, de-facto standard system development languages (C/C++, Java), multi-platform support, are all needed to develop an environment as described in section 2.1.
Table 1. List of requirements for the simulation system and description of resulting properties. connection both to recognise web-users as they log The middle layer of the environment consists of one in the environment, and associate them with their central persistent environment controller, which respective processes. controls and provides access to all the resources distributed in the environment. A user can The back-end layer consists of a number of shared interactively conduct a sequence of activities environment resources (applications) that are involving execution of applications on different accessible to the controller and multiple web-users platforms or trust this job to the controller. In the via, for instance, the Common Gateway Interface. latter case, the controller uses a special program The state of the real-world resources is represented called process (which prescribes the sequence of within the controller in a set of proxy objects called activities to be accomplished on behalf of the user). resources. A library of proxy modules provides the A kind of gateway mechanism is used to provide gateway mechanism of the controller with standard connectivity to the external resources. It interacts subroutines that “wrap” the real-world resources. with the user via interactive web pages (if additional Each proxy wrapper is developed for a particular input parameters are required to run the resource), (often legacy) application and stores the interface controls the session with the real resource, and definition of that server application and knows maintains the communication with the web-user. where to find the implementation of that resource. This mechanism conducts functionality essentially Finally, some kind of an inter-process (not to be related to that of Object Request Broker, and thus confused with user processes!) communication is has a very high appeal to apply one of the object needed to support communication between the technology standards. If the user logs out from the software components of this distributed system, the connection between the user and his/her environment. program (if any) is closed, but it does not affect the execution of the program in the system. A user state- saving mechanism is used by the server-side program causes the state of the environment (in our 2.2. Roles of POKer case, synthetic environment) to move (Þ) from We have chosen to base the environment’s middle state to state’. The state of the environment is layer on a process-oriented simulator (called POKer) represented by three components
3.4. newR(id) 3.7. close() Informally, it creates a new resource object under Informally, it removes the containing process name id and initialises it according to the resource instance from D. If such instance does not exist in D, capacity. This object is saved to the dictionary of then a warning is issued. resources (R) and its name to D. Semantics: Semantics: close() Þ let EL’ = current::EL in newR (id, Cap) let D’ = D – C in Þ if id Î D then error else main(EL’, R, D’) if Cap < 0 then error else let EL’ = current::EL in Note: is intended to be used as the last let R’ = R[id/([],Cap,true)] in hold() let D’ = D ++ id in command in a process to clean up the definition space main(EL’, R’, D’) and to do some other last-minute activities.
3.5. getR(id) 3.8. main() Informally, it requests a resource under name id. If Informally, it continuously executes the processes the resource is free, then it grants ownership to the from the EL, according to their event times. This calling process, and decreases its capacity value by execution is based on the next-event approach: the 1. Otherwise, it delays the process. next event to take place is always the execution of the first command in the body of the current process Semantics: getR (id) (current event notice on the EL). Þ if id Î Attr then error else case LOOKUP id R of Semantics: ([],Cap,true) Þ let Attr’ = Attr ++ id in lines main(EL,R,D) let EL’=(evt,C,Body,Attr’,data)::EL in let Cap’ = Cap – 1 in Þ case (EL,R,D) of if Cap’ <= 0 ([],R,D) then let fl = false in Þ sleep() else let fl = true in 05 let R’= R[id/([],Cap’,fl)] in | ((evt,C,[],Attr,data)::EL,R,D) main(EL’, R’, D) Þ if Attr ¹ [] then error else main(EL,R,D) | (Q,Cap,false) Þ let Q’ = Q @ [current] in 10 | ((evt,C,(b::Body),Attr,data)::EL,R,D) let R’ = R[id/(Q’,Cap,false)] in Þ let timeout = evt – wallclock() in main(EL, R’, D) if timeout > 0 then | anything else Þ error let Body’=b::Body in 15 let en=(evt,C,Body’,Attr,data)in let EL’ = en::EL in 3.6. putR(id) sleep(timeout) main(EL’,R,D) else Informally, it releases resource id. If the resource’s 20 case b of waiting queue is empty, then its capacity value is decP(classId, classDef) increased by 1. Otherwise, the first delayed process | newP(id, classId, dt) | hold(dt) is released by scheduling it at the same time as the | newR(id, Cap) current process and placing it on the EL after the 25 | getR(id) | putR(id) current process. | close() Semantics: Interpretation: putR (id) Þ if id Ï Attr then error else (line 03) If the EL is empty then the kernel goes into let Attr’ = Attr – id in let EL’= (evt,C, Body,Attr’,data)::EL in a sleep mode. case LOOKUP id R of (06) Otherwise, if the body of the first process on the can facilitate modular prototyping of the system in EL is empty, this process is removed. development. Given the interactivity of scripting languages, debugging and testing smaller modular (10) Otherwise, the kernel executes the first parts of code for correctness can be even further command from the body of the first process on EL. facilitated. It first defines the time left before the next event. For this purpose, main() contrasts the current time (wallclock) to the simulation time (time) of the 4.2. About Python imminent process (11). If the latter is still ahead, the kernel goes into a sleep mode (14-17). Otherwise, Python [11] is a modern language, which combines the kernel processes that event notice (21-27). the usability of traditional scripting languages (such as Tcl, Scheme, and Perl) and the power of advanced Note: In sleep mode, the kernel waits until a timeout programming tools typically found in systems occurs (if the timeout argument is present and not None) development languages (such as C/C++, Java). It is or until it is notified about any new processes on the EL. Once awakened or timed out, it continues execution. an interpreted, object-oriented, high-level programming language with clear syntax. Its high- level built-in data structures, combined with dynamic typing and dynamic binding, and easiness 4. Implementation of integration into C/C++ systems (and visa-versa), 4.1. Functional vs. Imperative language make it very attractive for rapid application development, as well as for use as a scripting or glue The chosen semantic background of process language to connect existing components together. interaction simulation languages was conveyed in notations adopted from modern functional The Python interpreter, extensive standard and 3rd languages, and therefore it would have been most party libraries (CGI, Sockets, interfaces to easy to do the implementation also in one of the pure distributed object architectures, etc.) are available in functional languages. Moreover, an important source or binary form without charge for all major feature of pure functional languages (functional platforms, and can be freely distributed [13]. languages with no side-effects) is that they allow Moreover, Python’s de-facto standard GUI package developing software, which is more amenable to Tkinter [8] is based on Tcl/Tk, a graphical user formal methods and easier to reason about. Using a interface toolkit that makes it possible to create pure functional language one can make assertions powerful GUIs [12]. Among other Python’s GUIs, about programs and prove these assertions to be Tkinter is the most commonly used one, and is correct. It is possible to do the same for traditional, almost the only one that is portable between Unix, imperative programs – but just much harder – via Mac and Windows. "exhaustive" testing [19], which may be reassuring The combination of the above-mentioned aspects but it can never be convincing. and features makes Python extremely suitable for Although the pure functional languages allow to prototyping in software development projects. prove correctness of the program, they lack some features that make it possible to write more efficient software, and proof-of-correctness can still be prone 4.3. POKer to human errors. As the result, our choice for prototyping and development of the simulation Due to the Python’s mature built-in object types, language (as well as the proposed environment) goes such as lists, dictionaries, tuples and the availability to an imperative language: the scripting of powerful operations to process them, the programming language Python (see section 4.2). In implementation process was quite straightforward. order to isolate side-effects of the program’s parts Moreover, there was no need (at least at this stage) from being visible to the rest of the program we are to extend Python’s built-in object types (e.g., by ‘encapsulating’ those parts from changing the global embedding them into ‘wrap’ classes) in order to implement the operational semantics of the language state of the program in a way similar to [15], and ensure that the parts of our imperative code have the constructs and components (EL, R, D). The same input-output behaviour as their functional following is a summary of some aspects intrinsic to versions. the given implementation. Programming and reasoning about run-time systems Tuples are written as series of arbitrary objects in of discrete-event simulation languages is difficult, parentheses (any further occurrences of such syntax because their operation involves dynamically in the code imply tuples). Because tuples are changing scenarios. The approach described above immutable, they provide some integrity and and a good understanding of operational semantics therefore are well suited to implement POKer pDemos POKer Remarks decP(classId, classDef) (decP,(classId, classDef)) newP(id, classId, dt) (newP,(id, classId, dt)) hold(dt) (hold,(dt,)) Additional argument value: None newR(id) (newR,(id, Cap)) Capacity is added getR(id) (getR,(id,)) putR(id) (putR,(id,)) close() (close,()) Table 2. pDemos and POKer commands. objects with defined structure (e.g., processes, implementation of the language constructs. Users resources, etc.). Another feature is that argument are free to provide their own implementation of lists in Python are also constructed as tuples. current. Sets (dictionaries) are written as series of enter() key:value pairs, separated by commas and this helper function assists entering event notices enclosed in curly brackets. Set processing can be on the EL efficiently implemented with the built-in Python gateway() operations. this subroutine provides connectivity to the Lists are written as a series of objects, separated by environment resources. It looks-up the proper commas and enclosed in square brackets. Python’s wrapper from the library of proxy modules and list object has already sufficient built-in operations, executes it in a separate thread or process (in the such as slicing, concatenation, etc. OS sense), otherwise the overhead associated with that execution would affect the integrity of POKer’s commands were implemented as modular the kernel’s timing mechanism. The above- referentially transparent subroutines that exhibit mentioned library consists of wrappers explicit input-output behaviour and are based on the developed for particular resources inherent to the respective operational semantics definitions. As the particular environment at hands. Therefore, users result, it is much easier to verify their correctness by have to provide their own libraries of wrappers interactively testing those subroutines in the for applications that are available in the command line of the Python interpreter. The effect environment at hand. of such interactive execution on the state of the system is immediately obvious and can be easily compared to the state, determined according to the 5. Syntax and semantics operational semantics. The definition of a particular language consists of The main routine is framed so that it executes the both syntax (how the various symbols of the first command of the current (first) process on the language may be combined) and semantics (the EL by calling the respective subroutine. This is meaning of the language constructs). Section 3 has accomplished with the Python built-in function already provided a sufficient coverage of the , by passing the tuple of the subroutine as apply() semantics. As for the former, it shares a lot with the argument along with the tuple of the subroutine’s original syntax of pDemos, a language demonstrated arguments: by Birtwistle and Tofts, and we direct the readers example 1: apply(subroutine, (arg1, arg2, …)) looking for a more detailed description to their work [2]. For our purposes, it would suffice to point out This approach allows executing commands in a only the differences introduced by our generic fashion, without knowing their names and implementation. arguments ahead of time. Commands All command subroutines and main() are packed As the consequence of using apply (see example 1), into a separate module called poker. Besides the POKer’s commands should be now represented as aforementioned subroutines, this module also compound objects (tuples), and therefore are subject contains three more objects: to the native Python syntax rules for such objects [16]. A summary of the syntax changes in POKer current() commands as contrasted against pDemos commands this class hides some supporting code (related to is given in table 2. such functionality as handling input/output channels, messages, etc.) that is irrelevant to the Processes The execution begins with process P0 declaring a In contrast to the process structure proposed by process body PD as a class (see table 3). Next is to Birtwistle and Tofts (example 2), the nesting create instances of processes and schedule them after introduced by a compound object PD is removed, all processes already existing on the EL (lines 2-4). and a new object (attribute data) is added to support Finally P0 calls close(). Execution of P0 unrolls data-flow of a process. This attribute holds a in a consecutive manner, for it does not include tasks reference to any intermediate data that is currently that would either reschedule (hold) or possibly associated with the process (for example, the address delay (getR) the process. After termination of P0, of the file with output data produced by the previous EL contains three processes P1, P2, P3. Notice, activity with an environment resource). that P1 and P2 both were allowed to use resource Additionally, the order of objects in the process is concurrently (6 and 8) while P3 became blocked changed (example 1): (line 10) and how the state of the resource is affected. This demonstrates the effect of capacity example 2: (id, PD(classDef, attr, evt)) being added to the resource. For the rest execution example 3: (evt, id, classDef, attr, data) of the processes is similar and obvious.
6. Example of a sample POKer program 7. Server POKer In this section we present an example of a POKer 7.1. Extending POKer program to demonstrate the usage of the semantics rules and step by step execution of such a program. The application of POKer is intended to operate in This program creates a generic process class PD and the environment as controller in a way it is described three instances (P1, P2, P3) of that class are in subsection 2.1. In order to enable POKer for such scheduled on the EL at simulation times 1, 2, 3 an undertaking, it has to be amended with additional respectively. Each of the processes acquires, uses, functionality. This is accomplished in a special and releases the same resource (B) with capacity 2. version of POKer, called Server POKer. This For simplicity, the processes simulate activities with advanced version of POKer is based on the original the resource (gateway mechanism is not used) by POKer and extends its functionality by wrapping it hold(3). in a class. The state of the system is: This class does not affect the state of the system, nor EL = [(0,'P0',PD0,[],[])], provides any direct functionality to the controlling of R = {'B':([],2,'true')}, D = {}, the environment. Its development and where: implementation was not based on formal operational semantics, but rather on usual programming PD0 = [ (decP, ('PD',[(getR,('B',)), (hold,(3,)), practice, and available standard and 3rd party (putR,('B',)), libraries with the needed functionality. As such, it is (close,())])), (newP, ('P1','PD',1)), more of a helper class that bridges the gap between (newP, ('P2','PD',2)), the controller’s core (language run-time system) and (newP, ('P3','PD',3)), (close,()) ] the rest of the environment components it has to interact with. This class is packed into a separate Python module named ServerPoker.
Lines Run-time messages 01 (0,P0,[]) Declares class PD ==> done 02 (0,P0,[]) Creates instance of PD ==> (1,P1,[]) entered EL 03 (0,P0,[]) Creates instance of PD ==> (2,P2,[]) entered EL 04 (0,P0,[]) Creates instance of PD ==> (3,P3,[]) entered EL 05 (0,P0,[]) Closes itself ==> (0,P0,[]) is removed from EL 06 (1,P1,[]) Gets (B,2,T) ==> (1,P1,B) owns (B,1,T) 07 (1,P1,[B]) waits for 3 ==> (4,P1,B) is rescheduled 08 (2,P2,[]) gets (B,1,T) ==> (2,P2,B) owns (B,0,F) 09 (2,P2,[B]) waits for 3 ==> (5,P2,B) 10 (3,P3,[]) gets (B,0,F) ==> (N,P3,[]) is blocked by (B,0,F) 11 (4,P1,[B]) puts (B,0,F) ==> (4,P1,[]) (B,0,F) freed (4,P3,[B]) 12 (4,P1,[]) closes itself ==> (4,P1,[]) is removed from EL 13 (4,P3,[B]) waits for 3 ==> (7,P3,B) 14 (5,P2,[B]) puts (B,0,F) ==> (5,P2,[]) freed (B,1,T) 15 (5,P2,[]) closes itself ==> (5,P2,[]) is removed from EL 16 (7,P3,[B]) puts (B,1,T) ==> (7,P3,[]) freed (B,2,T) 17 (7,P3,[]) closes itself ==> (7,P3,[]) is removed from EL 18 POKer: empty EL – simulation is complete Table 3. Run-time messages generated by the kernel. As the result, Server POKer (from the POKer() implementation viewpoint) is a combination of two Process a single POKer command. This is modules: poker, which implements the language intended to be an interactive POKer shell. run-time system, and , which uses ServerPoker save_state(state_filename) and extends it with “environment”-oriented poker Save the state of the kernel to the filename file functionality. A detailed discussion of Server POKer is beyond the scope of this paper. In following serve_forever() subsection 7.2 we give a brief description of the Handle an infinite number of events. It simply ServerPoker module. calls method handle_request() in an infinite loop. In addition, this subroutine complements the timing mechanism of POKer: 7.2. Description of ‘ServerPoker’ module whenever the POKer becomes idle, it would force the kernel thread into a sleep mode until The ServerPoker module consists of one class it becomes timed out or awakened. The latter is ServerPoker, which simplifies the task of setting caused by arrival of external events signalling up the environment controller (or server, as it is that the wall-clock time has reaches the next referred to in this subsection to stress its serving event time (time) or availability of new role). Creating the server requires several steps. First processes on the internal buffer. of all, one must instantiate the ServerPoker class, passing it the server_address, server_activate() state_filename and starting up the listener Activate POKer as server. It starts up the thread that executes processes from the and kernel threads. Then, call the kernel and looks-up the internal buffer for any new handle_request() or serve_forever() EL requests from users. method of the server object to process one or many user requests. The following is a description of the server_deactivate([save=1, state_filename]) ServerPoker class external methods: Deactivate POKer. It handles the normal servelet(conn, addr) termination of the kernel thread and calls the Process data from a socket-client (conn, following methods in order: addr). It receives the request, gets, processes, terminate_listener(), and (optionally) and puts the data on the internal buffer. save_state(). server_address The address on which the server is listening. The format of it is a tuple containing a string giving 8. Final remarks the address, and an integer port number: Obviously, the ideas behind POKer are not at all ('127.0.0.1', 80), for example. new but based on the research reported in [Birtwistle and Tofts 1994]. Novel are, however, our setup(state_filename, server_address) implementation in the scripting language Python and Re-initialise the class. ServerPoker the use of the resulting process-oriented discrete- start_listener() event kernel in the real-world management and Start a Socket Server. It starts up a Socket Server control of our collaborative environment in by creating a listener thread that 'listens' for development. We have chosen for a simulator as the socket connections at the given core of the collaborative environment in order to server_address. have all the time full overview on all that is happening in the environment. This should facilitate state_filename later on formal analysis of the environment, resource Full filename. This file contains the state (saved management, virtual product life cycle [17], etc. or initial) of the environment. In this paper we have presented the operational terminate_listener() semantics definition of the process-interaction Terminate Socket Server. It shuts down the language commands and the implementation of the socket binding and terminates normally the run-time system. Despite the fact, that conversion of listener thread. the semantics into an imperative language was not as handle_request() straightforward as it would have been in the case of Process a single event notice. The kernel's loop a functional one, the implementation benefited from iterates ones to process the imminent event from the available strong data-types and interactivity of the current process. the scripting language. Further, understanding the semantics of the execution of POKer programs helped us when proving the correctness of the [5] On-line demo of POKer: http://www.kbs.twi.tudelft.nl/ implementation by testing. In summary, having a Research/Projects/CollSim/Software/bin/PI/ good semantic background provided us with a clear, [6] On-line demo of Server POKer: short and unambiguous understanding of the http://www.kbs.twi.tudelft.nl/Research/Projects/CollSim/ Software/bin/index2.cgi language constructs, and thus facilitated the implementation and testing phase. Later on it might [7] NanoComp project homepage: http://nanocom.et.tudelft.nl/ facilitate reasoning about the properties of POKer, [8] Tkinter homepage: http://www.python.org/topics/ tkinter/ as new features are being added. [9] A. Levytskyy and E.J.H. Kerckhoffs, “Towards a Prototype All the run-time traces provided in this paper were Web-Based Collaborative Simulation Environment”, SCS: generated by the presented kernel. An on-line paper of the 5th Euromedia Conference, May 2000, pp. 60 – 66. demonstration of POKer is available from the Internet [5]. There is also another on-line demo [6] [10] A. Levytskyy and E.J.H. Kerckhoffs, “A Plain Python Simulator to Control a Collaborative Environment”, SCS: that shows the ability of Server POKer to handle paper of the 14th European Simulation Multi-conference processes from multiple web-users on the same set (ESM), May 2000, pp. 719 – 727. of shared resources. However, for that purpose the [11] Mark Lutz, “Programming Python”, O'Reilly & Associates, server must be started up before one can take part in Inc., October 1996. a demonstration. Should a reader be interested, [12] John K. Ousterhout, “Tcl and the Tk Toolkit”, Addison- please send your request via e-mail to the first author Wesley Publishing Co., 1996. of this paper. [13] Python homepage: http://www.python.org [14] Jerry Banks (Ed.), “Handbook Of Simulation. Principles, Acknowledgement Methodology, Advances, Applications, and Practice”, A Wiley-Interscience Publication, 1998, pp. 813 – 833. The research reported in this article is done in the [15] Jon G. Riecke and Ramesh Viswanathan, “Isolating Side framework of the NanoComp-project [7], sponsored Effects in Sequential Languages”, Papers of the 22nd ACM by the TU-Delft. SIGPLAN-SIGACT symposium on Principles of programming languages, 1995, pp. 1 – 12. [16] Guido van Rossum, Python Tutorial, Release 1.5.2, March References 2000: http://www.python.org/doc/current/tut/tut.html [1] O. Balci, The implementation of four conceptual [17] Vangheluwe and Vansteenkiste, Ghislain and Visipkov, frameworks for simulation modeling in high-level Vladimir and Merkuryev, Yuri and Merkuryeva, Galina languages. Proceedings of the 1988 Winter Simulation and Teilans, Artis, “Design of a User Friendly Modelling Conference, pp. 287 – 295. and Simulation Environment”, International European Simulation Multi-conference (ESM), June 1994, pp. 282 – [2] G. Birtwistle and C. Tofts, “An operational semantics of 286. process-oriented simulation languages: Part 1 pDemos”, Trans. Soc. Comput. Simul., 10(4), December 1994, [18] B.P. Zeigler, H. Praehofer, T.G. Kim, Theory of Modeling pp. 299 – 333. and Simulation. Second Edition. Integrating Discrete Event and Continuous Complex Dynamic Systems, Academic [3] A.C.-H. Chow, Parallel DEVS: A parallel, hierarchical, Press, 2000. modular modelling formalism and its distributed simulator. TRANSACTIONS of the Society for Computer Simulation [19] Ronald C. Van Wagenen, Charles R. Harrell, Achieving International, Volume 13, No. 2, 1996, pp. 55 – 67. Reliability in Simulation Software. Proceedings of the 1994 Winter Simulation Conference, pp. 695 – 699. [4] Yoke-Hean Low, Chu- Cheow Lim, Wentong Cai, Shell- Ying Huang, Wen-Jing Hsu, Sanjay Jain, and Stephen J. [20] J.S. Carson, Modeling And Simulation Worldviews. Turner, “Survey of Languages and Runtime Libraries for Proceedings of the 1993 Winter Simulation Conference, Parallel Discrete-Event Simulation”, Simulation 72:3, pp. 18 – 23. 1999, pp. 170 – 186.