A model-driven framework for developing multi-agent systems in emergency response environments

The low-code approach is an important area of research being developed to improve the rapid creation and performance of software applications. This approach allows developers and users to easily create software applications through an interactive interface. Existing research shows that the low-code approach accelerates the development process in innovative ways, saves effort and time, and reduces code complexity. This study analyses and compares automatic code generation and transformation techniques in low-code platforms. The study analyses the contributions of automatic code generation and transformation to software engineering processes and evaluates the impact of these techniques on software product quality and development speed. The importance of the Model-Based Development (MBD) approach in automated code generation processes is highlighted. It is stated that MBD provides benefits such as speeding up the software development process and reducing errors by enabling automatic code generation from high-level abstract models. In the study, various literature studies were evaluated to examine the impact of automatic code generation and transformation techniques on the application development process. These studies have shown how automatic code generation and transformation techniques are applied, what results are achieved and what contributions these techniques make to the software development process. The results of the study show that automatic code generation and transformation techniques have a great impact on the application development process. In particular, the acceleration of the software development process, the reduction of errors and the ability to produce more effective and efficient software products are important benefits of these techniques. In addition, it has been found that this approach increases the success of software projects by enabling software developers to produce fast and accurate solutions in complex systems. In this context, the importance of automatic code generation and transformation techniques plays an important role in software development processes.

Despite the existence of many agent programming environments and platforms, the developers may still encounter difficulties on implementing Multi-agent Systems (MASs) due to the complexity of agent features and agent interactions inside the MAS organizations. Working in a higher abstraction layer and modeling agent components within a model-driven engineering (MDE) process before going into depths of MAS implementation may facilitate MAS development. Perhaps the most popular way of applying MDE for MAS is based on creating Domain-specific Modeling Languages (DSMLs) with including appropriate integrated development environments (IDEs) in which both modeling and code generation for system-to-be-developed can be performed properly. Although IDEs of these MAS DSMLs provide some sort of checks on modeled systems according to the related DSML’s syntax and semantics descriptions, currently they do not have a built-in support for debugging these MAS models. That deficiency causes the agent developers not to be sure on the correctness of the prepared MAS model at the design phase. To help filling this gap, we introduce a conceptual generic debugging framework supporting the design of agent components inside the modeling environments of MAS DSMLs. The debugging framework is composed of 4 different metamodels and a simulator. Use of the proposed framework starts with modeling a MAS using a design language and transforming design model instances to a run-time model. According to the framework, the run-time model is simulated on a built-in simulator for debugging. The framework also provides a control mechanism for the simulation in the form of a simulation environment model.

Stencil computations are a class of algorithms operating on multi-dimensional arrays, which update array elements using their nearest-neighbors. This type of computation forms the basis for computer simulations across almost every field of science, such as computational fluid dynamics, weather simulation, and earthquake prediction. Its mostly regular data access patterns potentially enable it to take advantage of GPU's high computation and data bandwidth. However, manual GPU programming is time-consuming and error-prone, as well as requiring an in-depth knowledge of GPU architecture and programming. This is especially true when the target is high performance. To overcome the difficulties in manual programming, a number of stencil frameworks have been developed to automatically generate GPU codes from user-written stencil code, usually in a Domain Specific Language. The previous stencil frameworks prove that it is feasible to automatically generate GPU codes, but they also introduce a set of unprecedented challenges on generating highly-optimized GPU codes for real stencil applications that may consist of large calculations. This dissertation is based on the Chemora stencil code auto-generation framework, aiming to deal with large calculations existing in real stencil applications. Large stencil calculations usually consist of dozens of grid functions with a variety of stencil patterns, resulting in extremely large code-generation ways to generate code. This dissertation introduces two algorithms to be used in generating highly tuned code. First, we propose to map a calculation into one or more kernels. An algorithm is proposed to optimize the kernel mapping by improving thread-level parallelism and minimizing off-chip memory accesses. Next, we propose an efficiency-based buffering algorithm which operates by scoring a change in buffering strategy for a grid function (GF) using a performance estimation and resource usage. With the algorithm, a near optimal solution can be found in (b-1)N(N+1)/2 steps, instead of b^N steps, for a calculation with N GFs and b buffering strategies. The current Chemora framework supports six (i.e. b = 5) buffering strategies. Finally, an analytic performance model is proposed to predict the execution time of a code generation way. In addition, we wrote a set of micro-benchmarks to explore and measure some performance-critical GPU microarchitecture features and parameters for better performance modeling.

Simulating complex systems often requires highperformance software to be custom developed. However families of simulation problem do arise in which many computational tools, data structures and semantic ideas are shared in common. Software engineering mechanisms that support the sharing and reuse of developed code are strongly desirable to save cost on development effort, testing and validation effort, and specifically to lower the time involved from concept to implementation for a new simulation model. Domain-Specific Languages (DSLs) provide a valuable such mechanism and act as a semantic bridge between application domain expert and programmer. Even in cases of computational scientists where these two roles might be played by the same individual, a DSL provides a powerful mechanism to abstract domain-specific ideas to improve the development time by lowering the software code complexity. We discuss some families of complex systems simulation problem and some experiences with domain-specific languages and automatic code generation (ACG) tools – particularly when applied to manage simulations where parallel and distributed computing technologies are used to speed-up the process of statistics collection from the numerical experiments.

This chapter demonstrates how high-level code is automatically generated for multi-core processors. The code generation capability of the Verifiable Embedded Real-Time Application Framework (VERTAF) was extended to support multi-core processors in the new VERTAF/Multi-Core (VMC) framework for embedded systems. After users specify embedded software requirements via SysML models along with parallel task, parallel data, and parallel dataflow specifications, the code generator automatically generates parallel code. Using the digital video recording (DVR) system as a case study, we show the correctness and advantages of the VMC code generator. The main inputs of VMC code generator include the block definition diagrams, state machine diagrams, and requirement diagrams of the system to be designed. The proposed code generation in VMC not only significantly decreases the amount of manually-written code, but also provides a formal procedure for model-conforming code generation of multi-core embedded software.

General-purpose modeling languages are inadequate to model and visualize business processes precisely. An enterprise has its own vocabulary for modeling processes and its specific tasks may have attached data that define the tasks precisely. We propose using Domain Specific Modeling (DSM) languages to model business processes, such that an enterprise can define its own DSM language(s) capturing its vocabulary and data requirement. We suggest using UML profiles and UML activity diagrams as the semantic base for these DSM languages and present tools that are able to create a DSM language and tool support for a given domain. One tool, called ADSpecializer, can generate a UML profile and its tool support of a given application domain. The other tool, ADModeler, is used to create UML activity diagrams within such a domain-specific UML profile. The two tools enable an enterprise to efficiently define and utilize their own DSM language.

Succinct, declarative, and domain-specific modeling languages have many advantages when creating simulation models. However, it is often challenging to efficiently execute models defined in such languages. We use code generation for model-specific simulators. Code generation has been successfully applied for high-performance algorithms in many application domains. By generating tailored simulators for specific simulation models defined in a domain specific language, we get the best of both worlds: a succinct, declarative and formal presentation of the model and an efficient execution. We illustrate this based on a simple domain-specific language for biochemical reaction networks as well as on the network representation of the established BioNetGen language. We implement two approaches adopting the same simulation algorithms: one generic simulator that parses models at runtime and one generator that produces a simulator specialized to a given model based on partial evaluation and code generation. Akin to profile-guided optimization we also use dynamic execution of the model to further optimize the simulators. The performance of the approaches is carefully benchmarked using representative models of small to mid-sized biochemical reaction networks. The generic simulator achieves a performance similar to state of the art simulators in the domain, whereas the specialized simulator outperforms established simulation algorithms with a speedup of more than an order of magnitude. This repository contains the code generation software as described in the 2020 PADS paper Partial evaluation via code generation for static stochastic reaction network models.

Automatic code generation for production automotive powertrain applications introduces many challenges for the tool vendor. Resource efficiency, reliability, and product process development issues need to be addressed. Automatic code generation used for rapid prototyping systems usually will not satisfy the requirements necessary for production oriented code generation. Some of the requirements critical to automatic code generation are not immediately obvious to a tool vendor who is not active in the user's industry. The purpose of this paper is to address some of the most common requirements for production automotive powertrain code generation.

In this paper, we introduce platform specific modeling and code generation tools for the model driven development of multi-agent systems (MAS). These tools enable agent developers to model their MASs for the SEAGENT and the JADEX agent platforms based on the semantics and design principles of these platforms. The toolkit also provides automatic code generation for agent developers in order to implement their MASs on the target platforms. Generated codes may vary on type (e.g. Java class files, XML documents or ontologies) according to each platform's requirements.

Basically, aircraft engines can be divided into a control embedded system and a controlled system with its environment. The behaviour of the controlled system is given a priori, while the control system still needs to be designed in a way guaranteeing the correct overall behaviour under all operational conditions depending on the flight domain. A large quantity of functions in control systems can be described by a formal system expressed in block diagrams and state-based representations. These representations can be translated to formal based tools relying on the synchronous languages Signal and Statecharts. SACRES is a tool set supporting the design of safety-critical embedded control systems. It integrates the tools and specification techniques Statemate, Sildex, and Timing Diagrams with tool components for automatic code generation, formal verification based on model checking techniques, and an innovative approach for automatic code validation for target code generated from DC+. Technical achievements are The main benefits of the SACRES approach are reduced risks for design errors and decreased design times and costs for the development of dependable (safety critical) embedded systems. SACRES is an attempt to avoid unpredictability (particularly that arising from late feedback from testing) associated with development of safety critical systems, through the use of the maximum degree of automation, especially in respect of code generation and verification. An outstanding property of SACRES is the combination of specification styles and specification tools being applied in practice with automatic tools to establish provable correctness with respect to required properties. Both dependability and productivity are increased by automatic code generation from high-level specifications such that the generated code can be validated against higher levels by rigorous proofs. These techniques allow traditional tests by sampling to be replaced by rigorous checking techniques which correspond to 100% coverage of test cases. In order to address a global innovative approach in the near future which match the whole software configuration, the SACRES tool set should be interfaced with asynchronous techniques matching the operating system development. This raises an open question in the software development future new process.

Development of agent systems is naturally a complex task due to the fundamental characteristics of agents. In addition, agent internals and inter-agent behavior models inside Multi-agent Systems (MAS) may become even more difficult to implement when interactions of agents with web services on the Semantic Web are taken into account. Our approach consists of the utilization of a Domain-specific Modeling Language (DSML) during MAS development in order to cope with the abovementioned challenge. This paper describes how the formal semantics of this DSML can be defined by especially focusing on its viewpoint on agent-semantic service interactions and discusses the use of this semantics definition on MAS validation. Determined semantic rules are both defined and implemented by using Alloy specification language which has a strong description capability based on both relational and first-order logic.

ADELFE is a French acronym that means “Toolkit for Designing Software with Emergent Functionalities” (“Atelier de DEveloppement de Logiciels à Fonctionnalité Emergente” in French). ADELFE methodology is dedicated to applications characterized by openness and the need of the system adaptation to an environment. Its main goal is to help and guide any designer during the development of an Adaptive Multi-agent System (AMAS). An AMAS is characterized by the following points: it is plunged into an environment and composed of interdependent agents, each agent carries out a partial function and the agents, organization during runtime makes the system realize an emergent function. Actually, an agent is locally cooperative, i.e. it is able to recognize cooperation failures called Non-cooperative Situations (NCS, which could be related to exceptions in classical programs) and treat them.ADELFE includes five Work Definitions that were initially inspired from the Rational Unified Process (RUP) and gathers 21 activities, producing or refining 12 work products. These products are aggregating modelling diagrams or structured or free text. ADELFE, which is a Model-Driven (model-centred) development method, is not hardly dependent on Domain Specific Modelling Languages (DSML) but currently the recommendation is to use UML2 for general activities and to use AMASML (AMAS Modelling Language) and SpeADL (Species-based Modelling Language) for specific activities appearing in Analysis, Design or Implementation phases.KeywordsAdaptive Multi-agent Systems (AMAS)Domain-specific Modeling Languages (DSML)AMAS ApproachAMAS TheoryManagement Studies ConferenceThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

Model-Based Design with automatic flight code generation is used to develop a variety of aerospace electronic systems including integrated avionics, jet engine controls, and flight control systems. The software deployed in these systems undergoes rigorous verification and validation because the consequences of software failure are severe. New code checking and analysis tools have recently emerged with tight integrations to the modeling and code generation environment provided by Simulink.

Compared to General Purpose Modeling Languages (GPMLs), Domain Specific Modeling Languages (DSMLs) have brought increasing expressivity and conciseness through the use of concepts and notations, which are customized by the characteristics of a specific problem domain. However, the creation of completely new languages can significantly increase software development costs. An alternative approach to creating new DSMLs refers to a customization of existing modeling languages. The DSML creation process through a customization of existing languages is a special case of Language Embedding. The embedding provides customization of an inherited infrastructure to a given domain. This paper elaborates a Domain-Specific Modeling environment for embedding an arbitrary DSML into an arbitrary GPML. The environment enables uniform development of DSMLs in the form of a lightweight extension of existing modeling languages.

Model-based development methodologies are gaining ground as software applications are getting more and more complex while the pressure to decrease time-to-market continually increase. Domain-specific modeling tools that support system analysis, simulation, and automatic code generation can increase productivity. However, most domain-specific model translators are still manually written. This paper presents a technique that automatically generates a domain-specific application programming interface from the same metamodels that are used to define the domain-specific modeling language itself. This facilitates the creation of domain-specific model translators by providing a high-level abstraction hiding all the cumbersome modeling tool-specific implementation details from the developer. The approach is illustrated using the Generic Modeling Environment and the Microsoft .NET C# language.