XDEVS: A hybrid system modeling framework

Artificial neural networks (ANNs), a branch of artificial intelligence, has become a very interesting domain since the eighties when back-propagation (BP) learning algorithm for multilayer feed-forward architecture was introduced to solve nonlinear problems. It is used extensively to solve complex nonalgorithmic problems such as prediction, pattern recognition and clustering. However, in the context of a holistic study, there may be a need to integrate ANN with other models developed in various paradigms to solve a problem. In this paper, we suggest discrete event system specification (DEVS) be used as a model of computation (MoC) to make ANN models interoperable with other models (since all discrete event models can be expressed in DEVS, and continuous models can be approximated by DEVS). By combining ANN and DEVS, we can model the complex configuration of ANNs and express its internal workings. Therefore, we are extending the DEVS-based ANN proposed by Toma et al. [A new DEVS-based generic artficial neural network modeling approach, The 23rd European Modeling and Simulation Symp. (Simulation in Industry), Rome, Italy, 2011] for comparing multiple configuration parameters and learning algorithms and also to do prediction. The DEVS models are described using the high level language for system specification (HiLLS), [Maïga et al., A new approach to modeling dynamic structure systems, The 29th European Modeling and Simulation Symp. (Simulation in Industry), Leicester, United Kingdom, 2015] a graphical modeling language for clarity. The developed platform is a tool to transform ANN models into DEVS computational models, making them more reusable and more interoperable in the context of larger multi-perspective modeling and simulation (MAS).

Real-time systems modeling and verification is a complex task. In many cases, formal methods have been employed to deal with the complexity of these systems, but checking those models is usually unfeasible. Modeling and simulation methods introduce a means of validating these model’s specifications. In particular, Discrete Event System Specification (DEVS) models can be used for this purpose. Here, we introduce a new extension to the DEVS formalism, called the Rational Time-Advance DEVS (RTA-DEVS), which permits modeling the behavior of real-time systems that can be modeled by the classical DEVS; however, RTA-DEVS models can be formally checked with standard model-checking algorithms and tools. In order to do so, we introduce a procedure to create timed automata (TA) models that are behaviorally equivalent to the original RTA-DEVS models. This enables the use of the available TA tools and theories for formal model checking. Further, we introduce a methodology to transform classic DEVS models to RTA-DEVS models, thus enabling formal verification of classic DEVS with an acceptable accuracy.

The Routed Discrete Event System Specification (RDEVS) is a modular and hierarchical Modeling and Simulation (M&S) formalism based on the Discrete Event System Specification (DEVS) formalism that provides a set of design models for dealing with routing problems over DEVS. At the formal level, RDEVS models (as DEVS models themselves) are defined mathematically. However, software implementations of both formalisms are based on an object-oriented paradigm. Furthermore, at the implementation design level, the RDEVS formalism is represented by a conceptual model that uses DEVS simulators as execution engines. Even when RDEVS models can be executed with DEVS simulators, the resulting data (obtained as execution outputs) remains DEVS-based, restricting the study of event flows between models influenced by routing policies. This paper shows how the RDEVS formalism design was enhanced to include event tracking in the models without altering their expected behavior during simulation. Such an improvement is based on adding new features to existing RDEVS components. These features are defined as trackers, which are responsible for getting structured data from events exchanged during RDEVS executions. The proposed solution employs the Decorator pattern as a software engineering option to achieve the required goal. It was deployed as a Java package attached to the RDEVS library, devoted to collecting structured event flow data using JavaScript Object Notation (JSON). The results highlight the modeling benefits of adding event tracking to the original capabilities of the RDEVS formalism. For the M&S community, the novel contribution is an advance in understanding how best modeling practices of software engineering can be used to enhance their software tools in general and the RDEVS formalism in particular.

System models are constructed to design, study, and understand complex systems. According to the systems modeling language (SysML) that is a standard for model-based system engineering, all engineering activities should be performed using a common model. To validate complex system models defined in SysML, simulation is usually employed. There are numerous efforts to simulate SysML models using different simulation methods and tools. However, the efficient support of automated generation of executable simulation code is still an issue tangled by the research community. This paper introduces DEVSys, an integrated framework for utilizing existing SysML models and automatically producing executable discrete event simulation code, according to model driven architecture (MDA) concepts. Although this approach is not simulation-specific, discrete event system specification (DEVS) was employed, due to the similarities between SysML and DEVS, mainly in system structure description, and the mature, yet ongoing research on expressing executable DEVS models in a simulator-neutral manner. DEVSys framework elements include (a) a SysML profile for DEVS, enabling integration of simulation capabilities into SysML models, (b) a meta-model for DEVS, allowing the utilization of MDA concepts and tools, (c) a transformation of SysML models to DEVS models, using a standard model transformation language as query/view/transform (QVT), and (d) the generation of DEVS executable code for a DEVS simulation environment with an extensible markup language (XML) interface. The definition and implementation of DEVSys elements, as well as the process for its application are demonstrated and discussed, with the aid of a simple working example.

Discrete event system specification (DEVS), a formalism for modeling and simulation, has been recently applied to the engineering of CPS, which also makes the necessity of model checking for DEVS arisen. Model-transformation-based approaches were first proposed; timed or linear hybrid automata are obtained from DEVS models, and then verified using model checkers. But, due to the different semantics in state transitions, the transformation often involves manual tasks, such as abstraction and approximation. To eliminate such manual tasks, we have proposed a DEVS subclass that is less expressive, but verifiable. For reachability analysis, its models can be interpreted as transition systems and region automata (RA). Although our DEVS subclass and RA have different semantics with respect to model execution, they are equivalent in terms of reachability analysis. Thus, the reachability could be analyzed based on model checking techniques of timed automata. In many DEVS-based environments, models should be developed by programming languages. To enables the modelers to specify CPS in a visual way, we have proposed a visual modeling language based on our subclass. In our language, the behavior and structure of CPS are graphically specified by basic model diagrams and coupled model diagrams, respectively. Based on our subclass and languages, we have implemented a proof-of-concept environment that supports visual modeling of CPS as well as simulation and reachability analysis of the models. To enable the consideration of the hybrid nature and heterogeneity in CPS, DEVS subclasses, languages, verification techniques and environments will be further investigated.

Discrete event models are widely used to replicate, analyze, and understand complex systems. DEVS (Discrete Event System Specification) formalism enables hierarchical modeling, so it provides an efficiency in the model development of complex models. However, the hierarchical modeling incurs prolonged simulation executions due to indirect event exchanges through the model hierarchy. Although direct event paths are applied to mitigate this overhead, the situation becomes even worse when a model changes its structures during simulation execution, called a dynamic structure model. This article suggests Coupling Relation Graph (CRG) and Strongly Coupled Component (SCC) concepts to improve hierarchical and dynamic structure DEVS simulation execution. CRG is a directed graph representing DEVS model structure, and SCC is a group of connected components in a CRG. Using CRG and SCC, this article presents (1) how to develop CRG from a DEVS model and (2) how to construct and update direct event paths with respect to dynamic structural changes. In particular, compared to the previous works, the proposed method focuses on the reduction of the updating costs for the direct event paths. Through theoretical and empirical analyses, this article shows that the proposed method significantly reduces the simulation execution time, especially when a simulation model contains lots of components and changes its model structures frequently. We expect that the proposed method would support the faster simulation executions of complex hierarchical and dynamic structure models.

A hybrid model is a combination of models developed in various simulation development environments. A war game model is a kind of hybrid model and consists of multiple level models. Engineering level models are interested in the change of values via time and process mathematical equations, and most of them are developed in MALTAB/Simulink. Engagement level models are concerned about state transitions by events and modeled using the Discrete Event Systems Specification (DEVS) formalism. This paper proposes a framework for interoperation of simulation tools for engineering and engagement level models simulation. The framework employs the High Level Architecture (HLA) to reuse existing models and suggests specific interfaces for MATLAB/Simulink. The proposed framework is demonstrated through simulation of a simple war game model including heterogenous models.

Dynamic reconfigurable simulation based on Discrete Event System Specification (DEVS) requires efficient verification of simulation models. Traditional verification method of DEVS model is based on I/O test in which a DEVS model is regarded as a black box or a grey box. This method is low efficient and insufficient because input samples are often limited. This paper proposes a formal method which can translate Parallel DEVS model into a restrict kind of Timed Automata (TA) with equivalent behaviors. By this translation, a formal verification problem of Parallel DEVS model can be changed into the formal verification of according timed automata.

DEVS는 이산 사건 시스템을 명세하는 집합론에 근거한 수학적인 틀이다. 이러한 DEVS를 통해 시스템을 시뮬레이션할 때는 명세된 DEVS로부터 구현된 모델과 시뮬레이션 엔진으로 이루어진 실행 환경이 필요하다. 시뮬레이션 엔진은 스케줄링 알고리즘을 통해 모델을 해석하고 실행하는데, 주로 DEVS의 계층적이고 모듈러한 특성을 따라 계층적인 스케줄링 방법을 사용한다. 그러나 이 방법은 계층적인 구조로 인해 시간 관리와 메시지 패싱에 있어서 오버헤드가 존재한다. 본 논문에서는 이러한 오버헤드를 해결하기 위해 이벤트 지향 시뮬레이션을 적용한다. 이벤트 지향의 시뮬레이션은 이벤트에 의해서 모델이 실행되며 이벤트 리스트에 의해 이벤트가 관리된다. 이벤트 리스트에 의해서 시간 관리가 되고 메시지 패싱이 이루어지기 때문에 계층적인 오버헤드를 줄이고 성능 향상을 이룰 수 있다. 본 논문은 이벤트 리스트를 이용한 실행 환경을 제안하고 이러한 실행 환경을 위한 모델 구현 방안에 대해 논하며, 각 실행 환경의 성능을 비교, 분석한다. DEVS(Discrete Event Systems Specification) is a set theoretic formalism developed for specifying discrete event system. For execution of DEVS, we need an execution environment, which consists of simulation engine and models interpreted by the simulation engine. Common existing environments use hierarchical scheduling algorithm for DEVS execution. This hierarchical scheduling is a proper algorithm for DEVS execution because of hierarchical and modular characteristics. But this algorithm has overheads owing to message passing and time management. To overcome these overheads, we apply event-oriented simulation to DEVS execution and we remove hierarchical overheads. In eventoriented simulation, the scheduling of model execution is performed by events and event list. We propose three event-oriented execution environments for DEVS and experiment about the performance of our proposed environments in comparison with the existing execution environment using the hierarchical scheduling. The experimental results show our environments works better than existing environment using the hierarchical scheduling.

It is shown how systems can be advantageously represented as discrete event models by using DEVS (discrete event system specification), set-theoretic formalism. Such DEVS models provide a basis for the design of event-based logic control. In this control paradigm, the controller expects to receive confirming sensor responses to its control commands within definite time windows determined by its DEVS model of the system under control. The event-based control paradigm is applied in advanced robotic and intelligent automation, showing how classical process control can be readily interfaced with rule-based symbolic reasoning systems. >

Discrete Event System Specification (DEVS) is a popular formalism for modeling complex dynamic systems using a discrete-event abstraction. At this abstraction level, a timed sequence of pertinent "events" input to a system (or internal timeouts) cause instantaneous changes to the state of the system. Main advantages of DEVS are its rigorous formal definition and its support for modular composition. This tutorial introduces the Classic DEVS formalism in a bottom-up fashion, using a simple traffic light example. The syntax and operational semantics of atomic (i.e., non-hierarchical) models are introduced first. Coupled (i.e., hierarchical) models are introduced to structure and couple Atomic models. We continue to actual applications of DEVS, for example in performance analysis of queueing systems. All examples are presented with the tool PythonPDEVS, though this introduction is equally applicable to other DEVS tools. We conclude with further reading on DEVS theory, DEVS variants, and DEVS tools.

This paper presents a composable cognitive agent meta-model for multi-agent simulation based on the DEVS (Discrete Event System Specification) framework. We describe an attempt to compose a PRS-based cognitive agent by merely combining plug and play DEVS components, show how this DEVS-based cognitive agent meta-model is extensible to serve as a higher-level component for M&S of multi-agent systems, and how the agent meta-model components are reusable to ease cognitive agent modelling development. In addition to an overview of our agent meta-model, we also describe the components of the model specification and services in detail. To test the feasibility of our design, we constructed a simulation based on a Rock-Paper-Scissors game scenario. We also give out comparisons between this agent meta-model and other cognitive agent models. Our agent meta-model is novel in terms of both agent and agent components as these are all abstracted using the DEVS formalism. As different implementations of agent model components are based on the same meta-model components, all the developed agent model components can be reused in the development of other agent models which increases the composability of the agent model, and the whole cognitive agent model can be considered as a coupled model in the DEVS model hierarchy which supports multi-hierarchy modelling.

Discrete Event Systems Specification (DEVS) formalism supports the specification of discrete event models in a hierarchical and modular manner. Efforts have been made to develop the simulation environments for the modeling and simulation (M&S) of systems using DEVS formalism, particularly in defense M&S domains. This paper introduces the DEVSim++ toolset and its applications. The Object-Analysis Index (OAI) matrix is a tabular form of objects and analysis indices for requirements analysis. DEVSim++ is a realization of DEVS formalism in C++ for M&S. VeriTool is a DEVS model verification tool. DEVSimHLA is a library to support High-level Architecture (HLA) in DEVSim++. Other tools, including KComLib, FOM2CPPClass, and KHLAAdaptor, are used to develop a smart adaptor that allows for the interoperation of simulators of any kind. PlugSim is a distributed simulation framework using plug-in methods. These tools are utilized in every stage of the M&S development process, as well as in every application of the M&S missions to the military domain. Accordingly, the applications implemented by the toolset are used in the training, analytic, and acquisition missions of the Republic of Korea military branches. We expect the DEVS applications to become more prolific as M&S demands grow, and our toolset is already proven as complete and efficient in the domain of defense M&S.

Complex models in science and engineering need better techniques to execute simulations efficiently. As we need high performance computers with many processors and memory to execute complex simulations faster, we face a problem with the consumption of energy. Therefore, we need new ways to define efficiency in simulations, measured not only in terms of computation time, but in terms of the amount of energy required to execute them. The Discrete-Event System Specification (DEVS) formalism, a well-known technique for modeling and simulation, includes simulation algorithms that allow running DEVS models in parallel computers. Nevertheless, no studies exist on the execution of DEVS simulations on parallel computers efficiently in terms of energy use. In this work, we show an energy efficiency evaluation of the execution of DEVS simulations on a shared-memory multicore architecture. The results presented show that executing in parallel can improve energy efficiency in these architectures.

Employing Modeling and Simulation (M&S) extensively to analyze and develop complex systems is the norm today. The use of robust M&S formalisms and rigorous methodologies is essential to deal with complexity. Among them, the Discrete Event System Specification (DEVS) provides a solid framework for modeling structural, behavior and information aspects of any complex system. This gives several advantages to analyze and design complex systems: completeness, verifiability, extensibility, and maintainability. DEVS formalism has been implemented in many programming languages and executable on multiple platforms. In this paper, we describe the features of an M&S framework called xDEVS that builds upon the prevalent DEVS Application Programming Interface (API) for both modeling and simulation layers, promoting interoperability between the existing platform‐specific (C++, Java, Python) DEVS implementations. Additionally, the framework can simulate the same model using sequential, parallel, or distributed architectures. The M&S engine has been reinforced with several strategies to improve performance, as well as tools to perform model analysis and verification. Finally, xDEVS also facilitates systems engineers to apply the vision of model‐based systems engineering (MBSE), model‐driven engineering (MDE), and model‐driven systems engineering (MDSE) paradigms. We highlight the features of the proposed xDEVS framework with multiple examples and case studies illustrating the rigor and diversity of application domains it can support.