Search

There exist several approaches proposed for building Context-Aware Systems (CAS). However, due to the continually changing environment, the large number of interrelated components, complexity and diversity of application domains make the modelling of context-aware systems a particularly challenging task. To address the increasing complexity of the modelling: i) It is critical to take into account the importance of the environment (operational context); and ii) rely on software engineering concepts such as abstraction and modularity in order to reduce the level of complexity. Also, a context-aware system may require intelligence and autonomy. These naturally lead us to apply intelligent agent-based engineering. This work introduces a formal layered design approach that combines intelligent control of multi-agent systems and bigraph's rigor to model context-aware systems. Bigraphical reactive systems are particularly compelling for their capacity to specify, simultaneously, the physical and logical distribution of system components and their interconnections using two distinct structures; that is: place graph and link graph. While the behaviour and dynamic evolution are expressed using defined reaction rules, and as a last step, the bigraph specifications are coded in the Maude language to allow their execution and the verification of their validity.

Modeling the consumption of limited resources, e.g., time or energy, plays a central role on the design of reactive systems such as embedded controllers. To this aim, quantitative objectives are defined on game arenas that can be easily modeled as weighted graphs. Instances of these games, called energy games , can be solved in ${\mathcal {O}(\vert {E}\vert {\cdot }\vert {V}\vert {\cdot }W)}$ O ( | E | · | V | · W ) where $W$ W is the maximum weight. Recent work has demonstrated that sequential implementations hardly solve practical instances due to their size and the number of interactions required to converge to a solution. Recent work has demonstrated that sequential implementations hardly solve practical instances. Furthermore, emerging approaches, that have investigated the parallelism of CPUs multi-core and GPU for solving the initial credit problem for energy games, still perform poorly due to the non-trivial characteristics of these graphs. In this article we first describe a revised version of the algorithm on multi-core CPU that obtains a faster convergence time on real-world graphs with up to 30x against the serial implementation by showing good scalability overall. Second, we provide a new GPU-based parallel implementation based on warp-level primitives that allows to reduce the time-to-solution on several instances with up to 3.6x of speed-up against traditional parallel vertex-based approaches. We also discuss a methodology to build synthetic energy games to validate the scalability of parallel algorithms on two totally different settings.

A method for programming reactive systems, called scenario-based algorithmics, can have several advantages, both in programming and in computer science education. We provide new examples, experiments, and perspectives.

Editor’s notes: An important role of cross-layer design is to reconcile model-implementation differences, often stemming from how the two layers are specified. This article shows how a single method and tool can support both the specification and implementation stages, resulting in better closing the “model-implementation gap.” — Samarjit Chakraborty, University of North Carolina at Chapel Hill

Stochastic games combine controllable and adversarial non-determinism with stochastic behavior and are a common tool in control, verification and synthesis of reactive systems facing uncertainty. Multi-objective stochastic games are natural in situations where several - possibly conflicting - performance criteria like time and energy consumption are relevant. Such conjunctive combinations are the most studied multi-objective setting in the literature. In this paper, we consider the dual disjunctive problem. More concretely, we study turn-based stochastic two-player games on graphs where the winning condition is to guarantee at least one reachability or safety objective from a given set of alternatives. We present a fine-grained overview of strategy and computational complexity of such disjunctive queries (DQs) and provide new lower and upper bounds for several variants of the problem, significantly extending previous works. We also propose a novel value iteration-style algorithm for approximating the set of Pareto optimal thresholds for a given DQ., Comment: In Proceedings GandALF 2021, arXiv:2109.07798. arXiv admin note: substantial text overlap with arXiv:2108.04604

Object orientation is a powerful and widely used paradigm for abstraction and structuring in programming. Many languages are designed with this principle or support different degrees of object orientation. In synchronous languages, originally developed to design embedded reactive systems, there are only few object-oriented influences. However, especially in combination with a statechart notation, the modeling process can be improved by facilitating object orientation as we argue here. At the same time the graphical representation can be used to illustrate the object-oriented design of a system. Synchronous statechart dialects, such as the SCCharts language, provide deterministic concurrency for specifying safety-critical systems. Using SCCharts as an example, we illustrate how an object-oriented modeling approach that supports inheritance can be introduced. We further present how external, i.e., host language, objects can be included in the SCCharts language. Specifically, we discuss how the recently developed concepts of scheduling directives and scheduling policies can be used to ensure the determinism of objects while retaining encapsulation.

We present a new framework for the analysis of financial networks, called Actor-based Reactive Systems (ARS), that pushes further the Agent-Based approach (ABM) by resorting to ideas coming from the study of distributed systems in computer science. Two distinctive features, namely a fundamentally different management of time and a fully decentralized control logic, have a profound impact in terms of expressiveness of analysis, flexibility of modeling, and efficiency of experimentation. To illustrate the feasibility of the framework, we develop a realistic case study by analyzing the systemic risk of a model of the European banking network with a nontrivial contagion procedure, that combines an initial asset shock with the negative feedback loop triggered by asset fire sales. We show that, compared to ABMs, ARSs bring about finer-grained analyses, with a greater degree of heterogeneity and adaptivity of economic agents. Moreover, the very low computational cost and the detailed account of the system’s execution support the design and the development of very flexible stress tests to rapidly experiment with many hypothetical scenarios in a test-oriented style.

Reactive synthesis is an automated procedure to obtain a correct-by-construction reactive system from its temporal logic specification. This short paper discusses the software engineering challenges in applying reactive synthesis to robotics, beyond the synthesis algorithms themselves, including the challenge of writing declarative specifications, the challenge of abstraction of data and time, and the challenge of availability of an adequate development process supported by related tools. The identification and description of the challenges are based on our experience in building a development environment for reactive synthesis and applying it to the construction of about 10 different autonomous Lego robots. We describe the challenges using concrete examples from one of the robots built in our lab.

Specifications for reactive synthesis, an automated procedure to obtain a correct-by-construction reactive system, consist of assumptions and guarantees. One way a controller may satisfy the specification is by preventing the environment from satisfying the assumptions, without satisfying the guarantees. Although valid this solution is usually undesired and specifications that allow it are called non-well-separated. In this work we investigate non-well-separation in the context of GR(1), an expressive fragment of LTL that enables efficient synthesis. We distinguish different cases of non-well-separation, and compute strategies showing how the environment can be forced to violate its assumptions. Moreover, we show how to find a core, a minimal set of assumptions that lead to non-well-separation, and further extend our work to support past-time LTL and patterns. We implemented our work and evaluated it on 79 specifications. The evaluation shows that non-well-separation is a common problem in specifications and that our tools can be efficiently applied to identify it and its causes.

Linear Temporal Logic (LTL) is the standard specification language for reactive systems and is successfully applied in industrial settings. However, many shortcomings of LTL have been identified in the literature, among them the limited expressiveness, the lack of quantitative features, and the inability to express robustness. There is work on overcoming these shortcomings, but each of these is typically addressed in isolation. This is insufficient for applications where all shortcomings manifest themselves simultaneously. Here, we tackle this issue by introducing logics that address more than one shortcoming. To this end, we combine the logics Linear Dynamic Logic, Prompt-LTL, and robust LTL, each addressing one aspect, to new logics. For all combinations of two aspects, the resulting logic has the same desirable algorithmic properties as plain LTL. In particular, the highly efficient algorithmic backends that have been developed for LTL are also applicable to these new logics. Finally, we discuss how to address all three aspects simultaneously., In Proceedings GandALF 2019, arXiv:1909.05979. arXiv admin note: substantial text overlap with arXiv:1808.09028

Handling the microscopic level of Vehicle-Pedestrian interactions is highly useful for analyzing patterns-based pedestrian accident exposure. Recently proposed systems are based on vehicle-to-pedestrian communication to analyze real-time situations and thus warning both sides of potential crashes. Two parts are composing those systems. The first concerns network technologies ensuring direct communication between vehicles and pedestrians and the second is related to information processing analyzing and predicting trajectories and dangers. One of the most challenges facing the last systems category is to provide them with precise and sufficient data to test and improve them. Precisely, to analyze vehicle-pedestrian interactions, we suggest detecting pedestrian behavior with respect to its surrounding vehicles as well as detecting vehicle behavior with respect to its surrounding pedestrians. In this work, we consider generating pedestrians and vehicles’ data using SUMO. Moreover, we design a handler for preparing Vehicle-Pedestrian interactions data for upper layers for deep analytic and patterns finding purposes. Mixed realistic traffic simulation is performed in Mohammedia city and the first results are shown.

Introduction. Verification packages design and analyze the correctness of parallel and distributed systems within the framework of various classes of temporal logics of linear and branching time. The paper discusses a polynomially realizable class of ∆0T -formulas interpreted on multi-sorted models with hierarchical suspensions. The suspensionstructure is described by an arbitrary context-free (CF) grammar. The predicates and functions of the model signature are interpreted on the original CF-list, which is completed during the interpretation process.Materials and Methods. A constant model is constructed for theories from ∆0T-quasiidentities with Noetherian and confluence properties. We consider formulas of the multi-sorted first-order predicate calculus (PC) language with variables of the “list” sort interpreted on models with a hierarchized suspension. The theory is interpreted in terms of grammar inference trees describing the behavior of the specified system. The CF-grammar rules hierarchize the action space of the modeled system. It is noted that the expressive capabilities of Д0T-formulas are insufficient for modeling real-time systems. Therefore, expressions with unbounded universal quantifier V, known as PT formulas, are used for the specification.Results. The logical specification of an automated complex which consists of a workpiece manipulator is given as an example. The location of the positions is fixed by sensors. The operating cycle of the manipulator is described. The specification of its operation consists in the hierarchization of actions by the rules of the CF-grammar and their description by the first-order PT-formulas taking into account the time values.Discussion and Conclusions. The paper shows that the class of the considered formulas can be used to model real-time systems. An example of the logical specification of a manipulator behavior control device is given.

Sequential reactive systems include programs and devices that work with two streams of data and convert input streams of data into output streams. Such information processing systems include controllers, device drivers, computer interpreters. The result of the operation of such computing systems are infinite sequences of pairs of events of the request-response type, and, therefore, finite transducers are most often used as formal models for them. The behavior of transducers is represented by binary relations on infinite sequences, and so, traditional applied temporal logics (like HML, LTL, CTL, mu-calculus) are poorly suited as specification languages, since omega-languages, not binary relations on omega-words are used for interpretation of their formulae. To provide temporal logics with the ability to define properties of transformations that characterize the behavior ofreactive systems, we introduced new extensions ofthese logics, which have two distinctive features: 1) temporal operators are parameterized, and languages in the input alphabet oftransducers are used as parameters; 2) languages in the output alphabet oftransducers are used as basic predicates. Previously, we studied the expressive power ofnew extensions Reg-LTL and Reg-CTL ofthe well-known temporal logics oflinear and branching time LTL and CTL, in which it was allowed to use only regular languages for parameterization of temporal operators and basic predicates. We discovered that such a parameterization increases the expressive capabilities oftemporal logic, but preserves the decidability of the model checking problem. For the logics mentioned above, we have developed algorithms for the verification of finite transducers. At the next stage of our research on the new extensions of temporal logic designed for the specification and verification of sequential reactive systems, we studied the verification problem for these systems using the temporal logic Reg-CTL*, which is an extension ofthe Generalized Computational Tree Logics CTL*. In this paper we present an algorithm for checking the satisfiability of Reg-CTL* formulae on models of finite state transducers and show that this problem belongs to the complexity class ExpSpace.

Sequential reactive systems include hardware devices and software programs which operate in continuous interaction with the external environment, from which they receive streams of input signals (data, commands) and in response to them form streams of output signals. Systems of this type include controllers, network switches, program interpreters, system drivers. The behavior of some reactive systems is determined not only by the sequence of values of input signals, but also by the time of their arrival at the inputs of the system and the delays in computing the output signals. These aspects of reactive system computations are taken into account by real-time models of computation which include, in particular, realtime finite state machines (TFSMs). However, in most works where this class of real-time automata is studied a simple variant of TFSM semantics is used: the transduction relation computed by a TFSM is defined so that the elements of an output stream, regardless oftheir timestamps, follow in the same order as the corresponding elements ofthe input stream. This straightforward approach makes the model easier to analyze and manipulate, but it misses many important features of real-time computation. In this paper we study a more realistic semantics of TFSMs and show how to represent it by means of Labeled Transition Systems. The use of the new TFSM model also requires new approaches to the solution of verification problems in the framework of this model. For this purpose, we propose an alternative definition of TFSM computations by means of Labeled Transition Systems and show that the two definitions of semantics for the considered class of real-time finite state machines are in good agreement with each other. The use of TFSM semantics based on Labeled Transition Systems opens up the possibility of adapting well known real-time model checking techniques to the verification ofsequential reactive systems.

We define EVL, a minimal higher-order functional language for dealing with generic events. The notion of generic event extends the well-known notion of event traditionally used in a variety of areas, such as database management, concurrency, reactive systems and cybersecurity. Generic events were introduced in the context of a metamodel to deal with obligations in access control systems. Event specifications are represented as records and we use polymorphic record types to type events in our language. We show how the higher-order capabilities of EVL can be used in the context of Complex Event Processing (CEP), to define higher-order parameterised functions that deal with the usual CEP techniques.

This paper investigates scheduling methods for two-stage real-time systems (2S-RTSs) that execute aperiodic tasks with firm and soft end-to-end deadlines. 2S-RTSs are often used to capture task execution in reactive systems where the first stage is responsible for detecting and preprocessing irregularly occurring external events and the second stage for taking certain actions to react to the identified situations. Since aperiodic tasks have no regular arrival patterns, it is more appropriate for such 2S-RTS to adopt an online scheduler to make scheduling decisions according to the current system state. We prove that the 2S-RTS scheduling problem is NP-hard, and present a novel share-based heuristic scheduling algorithm, referred to as HS-2S-RTS, to accomplish efficient online scheduling. Different from traditional optimal schedulers that aim to ensure all hard and soft deadline constraints, the goal of HS-2S-RTS consists of ensuring all firm deadline constraints and maximizing the minimum processor share assigned to soft tasks. Since the processor resource assigned to soft tasks is optimized without affecting firm deadline constraints, the schedulability of both firm and soft tasks can be improved. To reduce the actual run-time overhead, we further propose a quasi-shared-based scheduling algorithm, referred to as qHS-2S-RTS, that can achieve equivalent scheduling performance to HS-2S-RTS. We also design a new admission control algorithm for HS-2S-RTS and qHS-2S-RTS, called HSAC-2S-RTS. Simulation results validate our theoretical analysis that qHS-2S-RTS and HS-2S-RTS are able to satisfy all feasible firm deadline constraints while improving the schedulability of soft tasks.

My interest in scientific metaphor focuses on its role in charting our search for knowledge of a world not yet known. How else is one to seek understanding of the new, of the not yet intelligible, ...

The increasing complexity of reactive systems can be mitigated with the use of components and composition languages in model-driven engineering. Designing composition languages is a challenge itself as both practical applicability (support for different composition approaches in various application domains), and precise formal semantics (support for verification and code generation) have to be taken into account. In our Gamma Statechart Composition Framework, we designed and implemented a composition language for the synchronous, cascade synchronous and asynchronous composition of statechart-based reactive components. We formalized the semantics of this composition language that provides the basis for generating composition-related Java source code as well as mapping the composite system to a back-end model checker for formal verification and model-based test case generation. In this paper, we present the composition language with its formal semantics, putting special emphasis on design decisions related to the language and their effects on verifiability and applicability. Furthermore, we demonstrate the design and verification functionality of the composition framework by presenting case studies from the cyber-physical system domain.

In recent years, new classes of highly dynamic, complex systems are gaining momentum. These classes include, but are not limited to IoT, smart cities, cyber-physical systems and sensor networks. These systems are characterized by the need to express behaviors driven by external and/or internal changes, i.e. they are reactive and context-aware. A desirable design feature of these systems is the ability of adapting their behavior to environment changes. In this paper, we propose an approach to support adaptive, reactive systems based on semantic runtime representations of their context, enabling the selection of equivalent behaviors, i.e. behaviors that have the same effect on the environment. The context representation and the related knowledge are managed by an engine designed according to a reference architecture and programmable through a declarative definition of sensors and actuators. The knowledge base of sensors and actuators (hosted by an RDF triplestore) is bound to the real world by grounding semantic elements to physical devices via REST APIs. The proposed architecture along with the defined ontology tries to address the main problems of dynamically re-configurable systems by exploiting a declarative, queryable approach to enable runtime reconfiguration with the help of (a) semantics to support discovery in heterogeneous environment, (b) composition logic to define alternative behaviors for variation points, (c) bi-causal connection life-cycle to avoid dangling links with the external environment. The proposal is validated in a case study aimed at designing an edge node for smart buildings dedicated to cultural heritage preservation.

Directed bigraphs are a meta-model which generalises Milner’s bigraphs by taking into account the request flow between controls and names. A key problem about these bigraphs is that of bigraph embedding, i.e., finding the embeddings of a bigraph inside a larger one. We present an algorithm for computing embeddings of directed bigraphs, via a reduction to a constraint satisfaction problem. We prove soundness and completeness of this algorithm, and provide an implementation in jLibBig, a general Java library for manipulating bigraphical reactive systems, together with some experimental results.

During reactive transport modeling, the computing cost associated with chemical equilibrium calculations can be 10 to 10,000 times higher than that of fluid flow, heat transfer, and species transport computations. These calculations are performed at least once per mesh cell and once per time step, amounting to billions of them throughout the simulation employing high-resolution meshes. To radically reduce the computing cost of chemical equilibrium calculations (each requiring an iterative solution of a system of nonlinear equations), we consider an on-demand machine learning algorithm that enables quick and accurate prediction of new chemical equilibrium states using the results of previously solved chemical equilibrium problems within the same reactive transport simulation. The training operations occur on-demand, rather than before the start of the simulation when it is not clear how many training points are needed to accurately and reliably predict all possible chemical conditions that may occur during the simulation. Each on-demand training operation consists of fully solving the equilibrium problem and storing some key information about the just computed chemical equilibrium state (which is used subsequently to rapidly predict similar states whenever possible). We study the performance of the on-demand learning algorithm, which is mass conservative by construction, by applying it to a reactive transport modeling example and achieve a speed-up of one or two orders of magnitude (depending on the activity model used). The implementation and numerical tests are carried out in Reaktoro (reaktoro.org), a unified open-source framework for modeling chemically reactive systems.

Cyber-Physical Systems (CPSs) are dynamic and reactive systems interacting with processes, environment and, sometimes, humans. They are often distributed with sensors and actuators, characterized for being smart, adaptive, predictive and react in real-time. Indeed, image- and video-processing pipelines are a prime source for environmental information for systems allowing them to take better decisions according to what they see. Therefore, in FitOptiVis, we are developing novel methods and tools to integrate complex image- and video-processing pipelines. FitOptiVis aims to deliver a reference architecture for describing and optimizing quality and resource management for imaging and video pipelines in CPSs both at design- and run-time. The architecture is concretized in low-power, high-performance, smart components, and in methods and tools for combined design-time and run-time multi-objective optimization and adaptation within system and environment constraints.

As software evolves, regression testing techniques are typically used to ensure the new changes are not adversely affecting the existing features. Despite recent advances, regression testing for distributed systems remains challenging and extremely costly. Existing techniques often require running a failing system several time before detecting a regression. As a result, conventional approaches that use re-execution without considering the inherent non-determinism of distributed systems, and providing no (or low) control over execution are inadequate in many ways. In this paper, we present MRegTest, a replay-based regression testing framework in the context of model-driven development to facilitate deterministic replay of traces for detecting regressions while offering sufficient control for the purpose of testing over the execution of the changed system. The experimental results show that compared to the traditional approaches that annotate traces with timestamps and variable values MRegTest detects almost all regressions while reducing the size of the trace significantly and incurring similar runtime overhead.

This paper gives an overview of the FMI 3.0 support for two kinds of clock-based simulations: Synchronous Clocked Simulation, and Scheduled Execution. The former is used when the information about multiple simultaneous events (cause and exact time of occurrence) can be unambiguously conveyed. The later facilitates real-time simulations comprising multiple black-box models, by allowing fine grained control over the computation time of sub-models. A formalization is presented along with example application scenarios, meant as an introduction to the conceptualization of clocks in the FMI Standard.

Widespread access to low-cost, high computing power allows for increased computerization of everyday life. However, high-performance computers alone cannot meet the demands of systems such as the Internet of Things or multi-agent robotic systems. For this reason, modern design methods are needed to develop new and extend existing projects. Because of high interest in this subject, many methodologies for designing the aforementioned systems have been developed. None of them, however, can be considered the default one to which others are compared to. Any useful methodology must provide some tools, versatility, and capability to verify its results. This paper presents an algorithm for verifying the correctness of multi-agent systems modeled as tracking bigraphical reactive systems and checking whether a behavior policy for the agents meets non-functional requirements. Memory complexity of methods used to construct behavior policies is also discussed, and a few ways to reduce it are proposed. Detailed examples of algorithm usage have been presented involving non-functional requirements regarding time and safety of behavior policy execution.

A general strategy is presented for constructing and validating permutationally invariant polynomial (PIP) expansions for chemical systems of any stoichiometry. Demonstrations are made for three categories of gas-phase dynamics and kinetics: collisional energy-transfer trajectories for predicting pressure-dependent kinetics, three-body collisions for describing transient van der Waals adducts relevant to atmospheric chemistry, and nonthermal reactivity via quasiclassical trajectories. In total, 30 systems are considered with up to 15 atoms and 39 degrees of freedom. Permutational invariance is enforced in PIP expansions with as many as 13 million terms and 13 permutationally distinct atom types by taking advantage of petascale computational resources. The quality of the PIP expansions is demonstrated through the systematic convergence of in-sample and out-of-sample errors with respect to both the number of training data and the order of the expansion, and these errors are shown to predict errors in the dynamics for both reactive and nonreactive applications. The parallelized code distributed as part of this work enables the automation of PIP generation for complex systems with multiple channels and flexible user-defined symmetry constraints and for automatically removing unphysical unconnected terms from the basis set expansions, all of which are required for simulating complex reactive systems.

In order to improve pedestrian safety, it is important to identify suitable routes for walking. This paper presents a real-time reactive system that aims to provide the safest route among all possible routes at a given time, based on intuitionistic fuzzy pedestrian risk modeling. It derives multi criteria decision making to support complex environments using membership and non-membership attributes to generate the intuitionistic fuzzy risk weighting graph based on risk measures. The proposed system involves the pgRouting open-source library that extends the PostGIS/PostgreSQL geospatial database, to provide geospatial routing capabilities. Therefore, we offer a web-location based service allowing pedestrians to enter their destination; then select a route using an intelligent algorithm; providing them with the safest route possible instead of the fastest route. This service will certainly help save lives and reduce pedestrian accidents to some extent.

A novel approach to the remote-control system for the compact multi-crystal energy-dispersive spectrometer for x-ray emission spectroscopy (XES) applications has been developed. This new approach is based on asynchronous communication between software components and on reactive design principles. In this paper, we identify the challenges we have faced, our solution to them as well as the implementation and future development prospects. The main motivation of this work was the development of a new holistic communication protocol that can be implemented to control various hardware components.

In Cloud Computing, microservices have been recently introduced for enabling the development of large-scale structures, which are scalable, agile and especially suitable for meeting the emerging demands. The asynchronous communication has facilitated using reactive system which managed in interaction challenges and even variation of load in modern systems. There are certain features of microservices like elasticity and resilience have considered for messages can be progressed through Reactive Microservices (RM) which consists of segregated components over event stream that can able to perform individually or shown with various microservices for reaching the event at final stages. The reactive principle in microservices have involved for individual possibility in every microservice components reference architecture include the components of microservices, which have the ability to develop, release, organize, scale, upgrade and retired individually. It has infused the necessary redundancy into the network for avoiding failure cascading, which maintains the system reactive in case of any failure. This paper has explored the RM architecture application and provides insights by assisting in reducing the developing demand to create resilient and scalable systems. The basic use case of microservice framework implementation has been illustrated by Vert.x, which act as the general toolkit to create RM and also the performance of both reactive and nonreactive implementation are compared as an alternate. The performance comparison can reveal how RM performs better than non-reactive microservices.

In order to develop reliable software and systems, we depend on practical techniques for the construction and analysis of such software and systems. This special issue of Software Tools for Technology Transfer presents various tool-supported techniques that can help with the construction and analysis of such reliable software and systems. The papers in this special issue are extended versions of selected conference papers from the proceedings of the 24th International Conference on Tools and Algorithms for the Construction and Analysis of Systems (TACAS 2018).

Spatio-temporal events often describe the movements of an object in terms of space, time, and potential other attributes. Significant knowledge can be inferred by analysing them, either individually or atomically in form of trajectories. The trajectories can abstract additional properties and lead to deeper value. Moreover, external contextual information can be attributed to them to change their structure and lead to different perspectives. Because of this potentially valuable knowledge, nowadays indoor and outdoor tracking devices are used everywhere; generating countless events instantaneously. However, the extraction of knowledge from such heterogeneous, massive data is not a trivial task. In other terms, there is a need for a sophisticated system that is efficient in terms of distributed computing, failure handling, responsiveness, and abstraction. To answer this need, our study incorporates a fully fledged, reactive system for big trajectory data management. The system is unique of its kind because it is actor-based and features responsiveness, resiliency, and elasticity. Furthermore, our system is implemented using Scala; hence, we have the expressive power of both the Object-Oriented (OO) and Functional Programming (FP) paradigms. Allowing us to reach a higher level of abstraction to be able to process any trajectory type. The scope of this paper is to detail our system and discuss elasticity, routing strategies, load balancing, and our proper fault-tolerance mechanism. To fulfill this study, we consider the Geolife project’s GPS trajectory dataset.

Model-Based Testing (MBT) is a well-known technique that employs formal models to represent reactive systems’ behavior and generates test cases. Such systems have been specified and verified using mostly Finite State Machines (FSMs). There is a plethora of test generation algorithms in the literature; most of them are based on graphs once an FSM can be formally defined as a graph. Nevertheless, there is a lack of studies on analyzing cost and efficiency of FSM-based test generation algorithms. This study compares graph-based algorithms adopted to generate test cases from FSM models. In particular, we compare the Chinese Postman Problem (CPP) and H-Switch Cover (HSC) algorithms with the well-known Depth-First Search (DFS) and Breadth-First Search (BFS) algorithms in the context of covering all-transitions and all-transition-pairs criteria in an FSM. First, a systematic literature mapping was conducted to summarize the methods that have been adopted in MBT, considering FSMs. Second, the main methods found were implemented and analyzed on randomly-generated FSMs, as well as real-world models that represent embedded systems of space applications. To make comparisons, we considered analyses in terms of cost (time), efficiency (mutant analysis) and characteristics of the generated test suites (number of test cases, average length of test cases, largest and smallest test cases, standard deviation and distribution of test cases). In general, CPP presented the best results in terms of number of test cases and test suite size. In addition, CPP also presented low distribution of average length compared to other algorithms.

One of the most simple models of computation suitable for representation of reactive systems behavior is a finite state transducer that operates on an input alphabet of control signals and an output alphabet of basic actions. The behavior of such a reactive system displays itself in the correspondence between the flow of control signals and sequence of basic actions performed by the system. We believe that the behavior of this kind requires more complex and expressive means of specifications than the conventional linear temporal logic ($$LTL$$). In this paper, we define a new language of formal specifications $$\mathcal{L}\mathcal{P}$$-$$LTL$$, which is an extension of LTL, specifically intended for describing the properties of transducer computations. In this extension, the temporal operators are parameterized by sets of words (languages) which describe flows of control signals that impact on a reactive system. Basic predicates in the ℒ𝒫-LTL formulas are also defined by the languages in the alphabet of basic actions; these languages describe the expected response of the system to the environmental influences. In our earlier papers, we considered a verification problem for finite state transducers with regard to specifications represented by the ℒ𝒫-$$LTL$$ and ℒ𝒫-$$CTL$$ formulas. It was shown that the problem is algorithmically solvable for both logics. The aim of this paper is to estimate the expressive power of ℒ𝒫-$$LTL$$ by comparing it with some well-known logics widely used in computer science for specification of reactive systems. Two fragments were isolated in the ℒ𝒫-LTL: ℒ𝒫-1-LTL and ℒ𝒫-n-LTL. We discovered that the specification language of ℒ𝒫-1-$$LTL$$ is more expressive than LTL, while the ℒ𝒫-n-$$LTL$$ fragment has the same expressive power as the monadic second order logic S1S. temporal logics, expressive power, specification, verification, Buchi automata, infinite words

Real-world PLC software is modular and composed of many different function blocks. Nevertheless, common approaches to PLC software verification do not leverage this but resort to inlining, or analyse instances of the same function block type independently. With the advent of constrained Horn clauses as the basis for automated program verification, many state-of-the-art verification procedures build upon them. We illustrate how this formalism allows for a uniform characterisation of PLC program semantics and safety goals, derived from reactive systems safety foundations. Furthermore, we give a natural extension of the resulting encoding which enables compositional reasoning about modular software. Due to the cyclic execution of PLCs, an engineer’s mental model of a single function block often exhibits state machine semantics – partitioning a block’s behaviour into different modes of operation. We illustrate how such a mode space, and similar high-level knowledge, can be integrated with our compositional characterisation. We investigate the impact of each technique on the model checking performance by characterising PLC software verification problems, both in a non-compositional and a compositional way that may incorporate mode transitions, and solving them with an SMT solver. Evaluation of our prototypical implementation on examples from the PLCopen Safety library shows the effectiveness of both the chosen formalism and using high-level summaries.

The synthesis of reactive systems from linear temporal logic (LTL) specifications is an important aspect in the design of reliable software and hardware. We present our adaption of the classic automata-theoretic approach to LTL synthesis, implemented in the tool Strix which has won the two last synthesis competitions (Syntcomp2018/2019). The presented approach is (1) structured, meaning that the states used in the construction have a semantic structure that is exploited in several ways, it performs a (2) forward exploration such that it often constructs only a small subset of the reachable states, and it is (3) incremental in the sense that it reuses results from previous inconclusive solution attempts. Further, we present and study different guiding heuristics that determine where to expand the on-demand constructed arena. Moreover, we show several techniques for extracting an implementation (Mealy machine or circuit) from the witness of the tree-automaton emptiness check. Lastly, the chosen constructions use a symbolic representation of the transition functions to reduce runtime and memory consumption. We evaluate the proposed techniques on the Syntcomp2019 benchmark set and show in more detail how the proposed techniques compare to the techniques implemented in other leading LTL synthesis tools.

This paper discusses the limitation of both Sequence Covering Array (SCA) and Covering Array (CA) for testing reactive system when the order of parameter-values is sensitive. In doing so, this paper proposes a new model to take the sequence values into consideration. Accordingly, by superimposing the CA onto SCA yields another type of combinatorial test suite termed Multi-Valued Sequence Covering Array (MVSCA) in a more generalized form. This superimposing is a challenging process due to NP-Hardness for both SCA and CA. Motivated by such a challenge, this paper presents the MVSCA with a working illustrative example to show the similarities and differences among combinatorial testing methods. Consequently, the MVSCA is a new trend that can be a research vehicle for researchers to develop new and/or modify existing combinatorial strategies to deal with the combinatorial explosion problem raised by the MVSCA.

We propose a test generation strategy from natural language (NL) requirements via translation into Coloured Petri Nets (CPN), an extension of Petri Nets that supports model structuring and provides a mature theory and powerful tool support. This approach extends our previous work on the NAT2TEST framework, which involves syntactic and semantic analyses of NL requirements and the generation of Data-Flow Reactive Systems (DFRS) as an intermediate representation, from which target formal models can be obtained for the purpose of test case generation. Our contributions include automating a systematic translation of DFRSs into CPN models, an extension to deal with time aspects, besides an empirical analysis of the CPN-based test generation strategy. The analyses considered examples both from the literature (a vending machine and a nuclear power plant control system), and from the aerospace and the automotive domain (a priority command control system and a turn indicator control system, respectively). We analysed performance and the ability to detect defects generated via mutation. The results provide evidence that the contribution proposed here is more efficient, besides being able to detect at least as many defects as our previous efforts.

Modern industrial society is filled with hybrid systems. The effectiveness of a control system is now a basic requirement in any institution. In general terms, hybrid systems are reactive systems that intermix discrete and continuous control components in which the discrete part of that control system makes the decision on behaving for the whole designed system and further decides if it can allow it to switch to another set of control protocols when appropriate conditions are availed. The continuous part only functions according to a specified protocol. Hybrid systems are common models used in digital (logic) and continuous networks and devices. Digital control programs detect, control, and supervise continuous and discrete systems using differential or difference equations. This principle was utilized in our design and reported thereof. Although this work developed a different method to deal with specific problems facing students at Technical University of Mombasa. An upgrade was recommended so as to extend the control system to the eye- impaired students and visitors. Since the issue of optimal smart control systems cannot be ignored in the design of new control systems with today's requirements in our learning institutions, it was concluded that further research was necessary to bring about a fully reliable and well-developed control system able to use real-time and real routes as they exist at the university ground. This work reports a hybrid control guide system designed and implemented at the Technical University of Mombasa.

The flamelet method has been used extensively as an affordable turbulence-combustion interaction model that obviates the need to solve the evolution equations for the species mass fractions during a large-eddy or Reynolds-averaged Navier–Stokes calculation of a reactive flow field, leading to substantial savings in the simulation time and enabling modeling with relatively complex kinetic mechanisms. The canonical problem analyzed and stored in a look-up array in the flamelet procedure usually assumes some baseline fields; in particular, the pressure is often specified at a fixed value that is characteristic of the examined configuration. However, pressure in supersonic combustion has significant dynamical roles, unlike in low-Mach number or incompressible flows, and a constant pressure field will not be adequate for the former. To remedy this problem, reaction rate in the combustor is often assumed to scale squarely with pressure. This approach, which is probably acceptable for low-speed, high pressure combustors, is not suitable for dealing with the variable pressure conditions in supersonic combustion. This paper focuses on the assessment of the aforementioned scaling, in absolute sense, and also relative to an approach where pressure is added as a control parameter in the flamelet library. To achieve this, three classes of reactive systems with different levels of modeling complexities are investigated to show that representative chemical variables do not scale squarely with pressure. For the case of supersonic combustion, the scaling treatment in general leads to over-prediction of pressure and combustion and also tends to stabilize the flame. To the knowledge of the authors, no previous studies have reported on the issues addressed in the present paper.

In this paper, an approach for integrated behavior modeling and simulation within model-based electric/electronic-architecture (EEA) descriptions is presented. It leverages actor-oriented and UML state chart behavior modeling to address complex reactive systems. A key contribution is the aggregation of cross-layer behavior specified at the logical function architecture layer and at the hardware layer together with further properties of the EEA, such as the current consumption of electronic control units (ECUs), the underlying network topology and execution aspects of functions. The EEA and behavior modeling is done in the common industry tool PREEvision. Using these static descriptions, a unified simulation model is synthesized and executed using Ptolemy II, which extends a previously developed approach. In addition, a general concept to feed back the simulation data into PREEvision is briefly described e.g., to further evaluate the gained results. Finally, a proof-of-concept is presented using an Adaptive Cruise Control application.

The Epistemology Of Computer Simulation (EOCS) has developed as an epistemological and methodological analysis of simulative sciences using quantitative computational models to represent and predict empirical phenomena of interest. In this paper, Executable Cell Biology (ECB) and Agent-Based Modelling (ABM) are examined to show how one may take advantage of qualitative computational models to evaluate reachability properties of reactive systems. In contrast to the thesis, advanced by EOCS, that computational models are not adequate representations of the simulated empirical systems, it is shown how the representational adequacy of qualitative models is essential to evaluate reachability properties. Justification theory, if not playing an essential role in EOCS, is exhibited to be involved in the process of advancing and corroborating model-based hypotheses about empirical systems in ECB and ABM. Finally, the practice of evaluating model-based hypothesis by testing the simulated systems is shown to constitute an argument in favour of the thesis that computer simulations in ECB and ABM can be put on a par with scientific experiments.

International audience; Elasticity property allows cloud systems to adapt to their input workload by provisioning and deprovisioning resources as the demand grows and drops. However, due to the unpredictable nature of workload, providing accurate action plans to manage a cloud system's elasticity is a particularly challenging task. In this study, the authors propose a bigraphical reactive system-based approach to provide a formal modelling of cloud systems’ structure using bigraphs, and their elastic behaviours using bigraphical reaction rules. They introduce elasticity strategies to describe cloud systems’ auto-adaptation behaviours. One step further, they encode the bigraphical specifications into Maude language to enable an autonomic executability of the elastic behaviours and verify their correctness. Finally, they propose a queuing-based approach to discuss and analyse elasticity strategies in cloud systems through different simulated scenarios.

The rise of streaming libraries such as Akka Stream, Reactive Extensions, and LINQ popularized the declarative functional style of data processing. The stream paradigm offers concise syntax to write down processing pipelines to consume the vast amounts of real-time data available today. These libraries offer the programmer a domain specific language (DSL) embedded in the host language to describe data streams. These libraries however, all suffer from extensibility issues. The semantics of a stream is hard-coded into the DSL language and cannot be changed by the user of the library. We introduce an approach to modify the semantics of a streaming library by means of meta-programming at both run-time and compile-time, and showcase its generality. We show that the expressiveness of the meta-facilities is strong enough to enable push and pull semantics, error handling, parallelism, and operator fusion. We evaluate our work by implementing the identified shortcomings in terms of a novel stream meta-architecture and show that its design and architecture adhere to the design principles of a meta-level architecture. The state of the art offers plenty of choice to programmers regarding reactive stream processing libraries. Expressing reactive systems is otherwise difficult to do in general purpose languages. Extensibility and fine-tuning should be possible in these libraries to ensure a broad variety of applications can be expressed within this single DSL.

In this paper, we present a reactive system for running flexible business process. We define two flexibility patterns based on BPMN (Business Process Model Notation) that deals with changes of resource requirements for business process. The business processes are built on an abstract level, using a BPMN model for the specification of the cloud service business process structure based on flexibility patterns, and the state-chart diagram for the specification of the cloud service business process behaviour. In fact, our approach is based on model driven engineering to facilitate the business process design for developers and free them from the lower cloud details during the running time of such applications. Moreover, the use of flexibility actions ensures the capacity of making a compromise between adapting rapidly and easily business process when running errors occur and keeping the effectiveness of these updated application models. This update is controlled by the real time system which is based on a machine learning algorithm to depict the appropriate cloud service to involve in the business process model using the right flexibility action. Finally, we present some results of our system.

Context-aware computing refers to system ability to sense its environment and modify its behavior for delivering suitable services. Having such kind of systems with the Near Field Communication (NFC) capability, opens new perspectives and research areas, allowing very useful type of applications known as NFC-based context-aware applications. These systems require correctness due to their applicability and then need to be proven formally using exhaustive analysis approach such as formal verification. In literature, most of works focuses on creating a general model for context aware systems ignoring the specificity of certain applications such as NFC applications where they present a higher complexity. We emphasize the existence of little or no work in this area supporting formal modeling. To boost it, we propose BigNFC as a novel formal-model based on Bigraphical Reactive Systems (BRS) taking account the interaction mode from the beginning, so we establish mapping between BRS and BigNFC components, where the structures are modelled as bigraphs and behaviors as rewriting rules. Finally, to validate our model, we have applied it on a real-life application and some properties were checked successfully.

This paper (1) summarizes the history of the RERS challenge for the analysis and verification of reactive systems, its profile and intentions, its relation to other competitions, and, in particular, its evolution due to the feedback of participants, and (2) presents the most recent development concerning the synthesis of hard benchmark problems. In particular, the second part proposes a way to tailor benchmarks according to the depths to which programs have to be investigated in order to find all errors. This gives benchmark designers a method to challenge contributors that try to perform well by excessive guessing., International journal on software tools for technology transfer;Bd 23. 2021, S. 917-930

International audience; This is the companion paper of a talk in the Gems of PODS series, that reviews the development, starting at PODS 1988, of a family of Datalog-like languages with procedural, forward chaining semantics, providing an alternative to the classical declarative, model-theoretic semantics. These languages also provide a unified formalism that can express important classes of queries including fixpoint, while, and all computable queries. They can also incorporate in a natural fashion updates and nondeterminism. Datalog variants with forward chaining semantics have been adopted in a variety of settings, including active databases, production systems, distributed data exchange, and data-driven reactive systems.

Although there are e-health systems for the care of elderly people, the reactive characteristics to enhance scalability and extensibility, and the use of this type of system in smart cities, have been little explored. To date, some studies have presented healthcare systems for specific purposes without an explicit approach for the development of health services. Moreover, software engineering is hindered by agile management challenges regarding development and deployment processes of new applications. This paper presents an approach to develop health Internet of Things (IoT) reactive applications that can be widely used in smart cities for the care of elderly individuals. The proposed approach is based on the Rozanski and Woods’s iterative architectural design process, the use of architectural patterns, and the Reactive Manifesto Principles. Furthermore, domain-driven design and the characteristics of the emerging fast data architecture are used to adapt the functionalities of services around the IoT, big data, and cloud computing paradigms. In addition, development and deployment processes are proposed as a set of tasks through DevOps techniques. The approach validation was carried out through the implementation of several e-health services, and various workload experiments were performed to measure scalability and performance in certain parts of the architecture. The system obtained is flexible, scalable, and capable of handling the data flow in near real time. Such features are useful for users who work collaboratively in the care of elderly people. With the accomplishment of these results, one can envision using this approach for building other e-health services.

Obstacle–Avoidance robots have become an essential field of study in recent years. This paper analyzes two cases that extend reactive systems focused on obstacle detection and its avoidance. The scenarios explored get data from their environments through sensors and generate information for the models based on artificial intelligence to obtain a reactive decision. The main contribution is focused on the discussion of aspects that allow for comparing both approaches, such as the heuristic approach implemented, requirements, restrictions, response time, and performance. The first case presents a mobile robot that applies a fuzzy inference system (FIS) to achieve soft turning basing its decision on depth image information. The second case introduces a mobile robot based on a multilayer perceptron (MLP) architecture, which is a class of feedforward artificial neural network (ANN), and ultrasonic sensors to decide how to move in an uncontrolled environment. The analysis of both options offers perspectives to choose between reactive Obstacle–Avoidance systems based on ultrasonic or Kinect sensors, models that infer optimal decisions applying fuzzy logic or artificial neural networks, with key elements and methods to design mobile robots with wheels. Therefore, we show how AI or Fuzzy Logic techniques allow us to design mobile robots that learn from their “experience” by making them safe and adjustable for new tasks, unlike traditional robots that use large programs to perform a specific task.

There is a growing tendency for using domain-specific languages, which help domain experts to stay focussed on abstract problem solutions. It is important to carefully design these languages and tools, which fundamentally perform model-to-model transformations. The quality of both usually decides the effectiveness of the subsequent development and therefore the quality of the final applications. However, as the complexity and safety requirements of modern systems grow, it becomes increasingly burdensome to create highly customized languages and difficult to provide reasonable overviews within these tools. This thesis introduces a new interactive model-based compilation methodology. Compilations for arbitrary model-to-model transformations are themselves described as models. They can be instantiated for particular inputs, e. g. a program, to create concrete compilation runs, which return the result of that compilation. The compilation instance is interactively observable. Intermediate results serve as new inputs and as documentation. They can be used to create highly customized views and facilitate understandability. This methodology guides modellers from the start of the compilation to the final result so that they can interactively refine their models. The methodology has been implemented and validated as the KIELER Compiler (KiCo) and is available as part of the KIELER open-source project. It is used to implement the current reference compiler for the SCCharts language, a statecharts dialect designed for specifying safety-critical reactive systems based on a synchronous model of computation. The interactive model-based compilation approach was key to the rapid prototyping of three different compilation strategies, as well as new language extensions, variations and closely related languages. The results are verified with benchmarks, which are again modelled using the same approach and technology. The usability of the SCCharts language and the KiCo tooling is documented with long-term surveys and real-life industrial, academic and teaching examples.