Agents relying purely on imitation learning (IL) or reinforcement learning (RL) often struggle to avoid safety-critical errors during exploration. Existing RL approaches for environments such as chess require hundreds of thousands of episodes and substantial computational resources to converge. Unlike RL, IL enables efficient policy learning from expert demonstrations without requiring costly trial-and-error interaction, making it well-suited for complex domains like chess. In addition, IL can capture nuanced, human-aligned behaviors such as strategic patterns and stylistic preferences. However, IL-based agents may inherit biases from training data and lack safeguards against rare but critical mistakes, such as tactical blunders that can decisively impact game outcomes. In this work, we propose Oracle-Guided Soft Shielding (OGSS), a simple yet effective framework for safer move prediction, enabling safe exploration by learning a probabilistic safety model from oracle feedback in an imitation learning setting. In the domain of chess, we employ a two-model architecture: a move prediction model predicts strong moves from expert games, and a blunder model, trained on Stockfish evaluations, estimates tactical risk. At inference, the agent scores candidate moves using a utility function that combines move likelihood and blunder probability, enabling safe yet competitive game-play. When compared to other prominent methods such as action pruning, SafeDAgger, and uncertainty-based sampling, our results demonstrate that OGSS variants maintain a lower blunder rate even as the agent’s exploration ratio is increased by several folds, highlighting its ability to support broader exploration without compromising tactical soundness.

This paper presents the Ontology Language for the Dependability of Automated Systems (OLDAS), a modeling language based on Unified Modeling Language (UML) that aims to support dependability assessment for Automated Systems (ASs), i.e., systems intended to perform a function with minimal or no human intervention. OLDAS extends the Unified Foundational Ontology (UFO) and embeds validation rules to prevent constraint violations in ASs analysis. Specifically, the paper presents how OLDAS can support different activities during the design of ASs, from the definition of the Operational Design Domain to scenario-based analysis. OLDAS is available as a plugin of the open-source Papyrus for Robotics framework.

Dynamic Dependability Management (DDM) is a promising approach to guarantee and monitor the ability of safety-critical Automated Systems (ASs) to deliver the intended service with an acceptable risk level. However, the non-interpretability and lack of specifications of the Learning-Enabled Components (LECs) used in ASs make this mission particularly challenging. Some existing DDM techniques overcome these limitations by using probabilistic environmental perception knowledge associated with predicting behavior changes for the agents in the environment. We propose to improve these techniques with a supervisory system that considers hazard analysis and risk assessment from the design stage. This hazard analysis is based on a characterization of the AS's operational domain (i.e., its scenario space, including unsafe ones). The proposed supervisory system also considers the uncertainty estimation and interaction between AS components through the whole perception-planning-control pipeline. Our framework then proposes leveraging and handling uncertainty from LEC components toward building safer ASs.

International audience

Requirements engineering starts by requirements elicitation which consists in gathering software requirements from stakeholders.Then, the elicited requirements are usually manually recorded in a requirements specification document.In recent years, modern software projects are becoming more complex than projects of the past due to the increase in the number of requirements and stakeholders involved in a project.Thus, manually managing requirements becomes a tedious, time consuming and error-prone task.One historical strategy to manage this kind of complexity is "divide to conquer", meaning to categorize them into groups in order to breakdown the system into a set of smallest sub-systems at early stages.In this paper, we propose an approach to automatically cluster functional requirements based on their semantic similarity which is the usual strategy used by system architects to define sub-systems candidate to simplification of the original problem.First, we use word2vec, as a predictive word embedding model to compute the word-level similarity.Second, we derive the requirement-level similarity using a scoring function for text similarity.Third, we adopt hierarchical clustering to group the requirements.Experimental results performed on four open-access software projects show that our approach succeeded to improve the results of clusters identification compared with existing studies.

This paper tackles the scheduling of loop-intensive applications modeled by synchronous dataflow graphs (SDFGs) on heterogeneous multiprocessor architectures under resource and communication constraints. Scheduling an application graph on multiprocessor architectures under resource constraints is a well-known NP-hard problem widely addressed in the previous decades with the goal of optimizing different performance metrics such as latency, memory allocations, energy consumption, throughput, etc. In this paper, we focus on the study of cyclic scheduling strategies and specifically the software pipelined schedules of SDFGs under the resource and communication constraints of heterogeneous multiprocessor architectures and we made two major contributions. The first contribution is an integer linear programming (ILP) model for the exact resolution of the scheduling problem and the second contribution is a time-efficient heuristic that generates scheduling solutions close to the optimal solutions generated with our ILP model.

The complexity and intelligence of energy systems has increased in the recent years, whereas using Multi-agents system (MAS) technology has been recommended by IEEE for developing software solutions for modeling, controlling, and simulating their behaviors. Available MAS solutions for energy systems are generally designed for resolving specific problems by proposing ad-hoc solutions, without considering interoperability and reusability. We propose a methodology, based on the Model-Driven Engineering (MDE) technique, for developing MAS solutions for energy systems. Our methodology uses the Common Information Model standard (CIM), recommended by IEEE, and the existing Platform Independent agent metamodel PIM4Agents. Our proposal allows modeling MAS solutions for power engineering applications, by means of a platform independent model that abstracts developers from existing agent-oriented methodologies and platforms. Applying model transformations, the generated models can be transformed and executed within several agent platforms such as JACK and JADE. The proposal has been partially validated by means of a well-known test case.

Model-Driven Engineering (MDE) is a development paradigm that brings the benefits of increased automation to the software development cycle. The MDE community tries to promote MDE adoption by pushing models written in diagram-based languages, supported by extensive tooling. While there is increasing evidence that MDE facilitates the design of complex software, its level of acceptance by software developers is still low. On one hand, rather than use diagram-based languages, most programmers prefer to work with their favorite textual programming language (e.g. Java and C++) and integrated development environment. On the other hand, software architects are among the early adopters and promoters of diagram-based languages. They consider such languages to be much more suitable for describing architectures compared to textual languages. Synchronizing manually written artifacts in either type of language is not simple and is often very time-consuming and error prone unless it is supported by automated methods and tools. To solve this issue, we propose a methodological pattern for model-code synchronization supported by corresponding tooling. The solution tackles a fundamental problem of round-trip engineering: synchronization between concurrently evolving artifacts. On one side we have the architecture model maintained by the software architects, while on the other, we have code written by programmers. Applying our approach for the development of an actual runtime system, we show that both parties involved, software architects and programmers, can efficiently collaborate while continuing to work in their favorite development environment.

The adoption of AUTOSAR and Model Driven Engineering (MDE) for the design of automotive software architectures allows an early analysis of system properties and the automatic synthesis of architecture and software implementation. To select and configure the architecture with respect to timing constraints, knowledge about the worst case execution times (WCET) of functions is required. An accurate evaluation of the WCET is only possible when reusing legacy functionality or very late in the development and procurement process. To drive the integration of SW components belonging to systems with timing constraints, automotive methodologies propose to assign WCET budgets to functions. This paper presents two solutions to assign budgets, while considering at the same time the problem of SW/HW synthesis. The first solution is a one-step algorithm. The second is an iterative improvement procedure with a staged approach that scales better to very large size systems. Both methods are evaluated on industrial systems to study their effectiveness and scalability.

Synthesis of automotive architectures is a complex problem that needs an automated support. AUTOSAR, standard for the specification of automotive architectures, defines a synthesis process of software components and their connections in a set of fixed-priority OS tasks distributed over a network of ECUs. During the synthesis process software components are allocated on ECU-s. Since each component encapsulates a set of so-called runnable entities, synthesis completes by partitioning runnable entities in OS tasks with assigned fixed priorities. This paper proposes an optimization approach for the synthesis of AUTOSAR architectures based on genetic algorithms and mixed integer linear programming techniques. Optimization criteria consider end-to-end timing responses and memory consumption.

Modern development methodologies from the industry and the academia for complex real-time systems define a stage in which application functions are deployed onto an execution platform. The deployment consists of the placement of functions on a distributed network of nodes, the partitioning of functions in tasks and the scheduling of tasks and messages. None of the existing optimization techniques deal with the three stages of the deployment problem at the same time. In this paper, we present a staged approach towards the efficient deployment of real-time functions based on genetic algorithms and mixed integer linear programming techniques. Application to case studies shows the applicability of the method to industry-size systems and the quality of the obtained solutions when compared to the true optimum for small size examples.

Time budgets represent early estimates of execution times of system functions. They are assigned based on engineers experience and serve as an input for the early stage performance or schedulability analysis. This schedulability analysis test might become irrelevant if the computed worst-case execution times of a system functions exceed corresponding time budgets. This paper presents a solution based on the reallocation of system functions among OS tasks that preserves schedulability of the system. It is adapted to the linear computation model which is representative of a large number of systems, inter alia automotive systems.

Due to the definition of fUML (Foundational Subset for Executable UML Models) along with its action language Alf (Action Language for fUML), UML (Unified Modeling Language) allows the production of executable models on which early verification and validation activities can be conducted. Despite this effort of standardization and the large use of UML in industry, developers still hand tune the code generated from models to correct, enhance or optimize it. This results in a gap between the model and the generated code. Manual code tuning except from being error prone can invalidate all the analysis and validations already done in the model. To avoid the code hand tuning drawbacks and, since UML is becoming an executable language, we propose a new Model Based Development (MBD) approach that skips the code generation step by compiling directly UML models. The biggest challenge for this approach - tackled in this paper is to propose a model compiler that is more efficient than a code compiler for UML models. Our model compiler performs optimizations that code compilers are unable to perform resulting in a more compact assembly code.

In this paper, we present different modeling and execution frameworks that allow us to efficiently analyze, design and verify complex systems, mainly to cope with the specific concerns of the Real-time and embedded systems (RTE) domain. First we depict a UML /MARTE based methodology for executable RTE systems modeling with a framework and its underlying model transformations required to execute UML models conforming to the MARTE standard. The advantages of adopting a more generic action language with formal features are highlighted, in order to raise the level of abstraction with formal features. Then, we investigate how MARTE, with its Time Model facilities, can be made to represent faithfully AADL periodic/aperiodic tasks communicating through event or data ports, in an approach to end-to-end flow latency analysis. An analytical framework allows us to optimize port-based communication by generating a run time executive that utilizes shared data areas where appropriate, while ensuring the timing semantic assumed by the control application. An analysis of the AADL mode change protocol is also provided, exposing a translation process that takes as an input an AADL model and produces as an output a time Petri net. We show how an AADL model transformation provides a formal model for model checking activities and we suggest that model transformation provides useful support to improve the integration of formal verification in an industrial engineering process. As a case study we use an implementation of a UDP /IP protocol stack.

The paper extends the AUTOSAR meta-model to enable feasibility predictions on the provision of fault-tolerant support for application components. We focus on a fault-tolerant support based on software replication techniques. The meta-model is extended in order to evaluate different replication strategies, in terms of replication styles, types of faults to be tolerated, replicas placement. This extension is realized by a UML profile. A model-based approach is presented aiming at the definition of a so-called Application Replication View, in which a replication strategy is specified for safety critical application components. A separate model, called Application Timing View, defines timing constraints for system responses. The combination of the two views will enable schedulability analysis of the fault-tolerant application. Schedulability analysis considers the task set composed of application tasks and the additional tasks injected by replication. An automotive case study is presented showing the applicability of the approach.

Model-Based Development (MBD) provides an additional level of abstraction, the model, which lets engineers focus on the business aspect of the developed system. MBD permits automatic treatments of these models with dedicated tools like synthesis of system's application by automatic code generation. Real-Time and Embedded Systems (RTES) are often constrained by their environment and/or the resources they own in terms of memory, energy consumption with respect to performance requirements. Hence, an important problem to deal with in RTES development is linked to the optimization of their software part. Although automatic code generation and the use of optimizing compilers bring some answers to application optimization issue, we will show in this paper that optimization results may be enhanced by adding a new level of optimizations in the modeling process. Our arguments are illustrated with examples of the Unified Modeling Language (UML) state machines diagrams which are widely used for control aspect modeling of RTES. The well-known Gnu Compiler Collection (GCC) is used for this study. The paper concludes on a proposal of two step optimization approach that allows reusing as they are, existing compiler optimizations.

In model based approaches for real-time systems (RTS) development, an iterative process that consists in the early stage verification of real-time constraints fulfillment according to a given design is usually performed in order to detect as early as possible unfeasible designs. Schedulability analysis allows this early verification of timing constraints according to so called Schedulability Analysis Model (SAM). This paper proposes a configurable framework for implementation synthesis of component oriented specification that is able to preserve the SAM timing properties that are validated at an early stage of the RTS design.

This paper addresses the problem of code optimization for Real-Time and Embedded Systems (RTES). Such systems are designed using Model-Based Development (MBD)approach that consists of performing three major steps: building models, generating code from them and compiling the generated code. Actually, during the code generation, an important part of the modeling language semantics which could be useful for optimization is lost, thus, making impossible some optimizations achievement. This paper shows how adding a new level of optimization at the model level results in a more compact code. It also discusses the impact of the code generation on optimization: whether this step promotes or prevents optimizations. We conclude on a proposal of a new MBD approach containing only steps that advance optimization: modeling and compiling steps.

This presentation demonstrates the early results from the French ANR project RT-Simex. RT-Simex proposes a set of tools to analyze parallel embedded code and trace the simulation results back to the initial models from which the code was generated. The whole tool-set relies on standard formats (UML MARTE, Open Trace Format) to ensure a perennial use. The main difficulty is to reconcile different execution traces extracted from codes running concurrently on different unsynchronized platforms. This is achieved through the polychronous logical time model of MARTE.

The UML is now the most widespread language for systems modeling. However, this language has been designed as a general purpose modeling language that may lack for modeling constructs for specific domain, as for the real-time embedded (RTE) domain. In order to fill this lack, OMG has standardized a UML extension, called MARTE. This UML profile consists of specific concepts defined to cope with the specific concerns of the RTE domain. Of course, MARTE provides support for enabling model driven engineering (MDE) of RTE systems. The MDE development paradigm makes the model the first class citizen of development processes. Models need then to be productive. To achieve this purpose, providing methodology enabling model to be executable is a real challenge. The goal of this paper is then to present, on the one hand a UML/MARTE based methodology for executable RTE systems modeling and on the other hand, a framework and its underlying model transformations required to execute UML models conforming to the MARTE standard.

Real-time (RT) applications are designed to control systems that are inherently parallel. For easing development, abstractions are mandatory to model this concurrency. To achieve this goal, the real-time object paradigm is proposed. It is used to demonstrate how to separate functional and concurrency concerns ensuring also high-level abstraction for parallelism modeling

Moving from code-oriented to model-oriented development facilitates significantly management of increasingly complex software. As explained in [1], clear separation of concerns during application development can drastically increase maintainability, reusability and complexity management. Although existing UML-based approaches for real-time systems development do help speed up software development, they still result in models that are hard to maintain and reuse. This drawback is mainly due to a failure to apply the principles of separating concerns. This paper presents an UML-based method using Aspect Principles and dedicated to the development of real-time embedded systems. It focuses mainly on how suitable separation of concerns may ease reusability and maintainability. Specifically, it depicts how application behavior can be clearly modeled applying separation of control and computation aspects of behavior in UML.