: Automated extraction of state machine models from source code can improve comprehension of software system behavior required for many maintenance tasks and reuse in general. Furthermore, it can be used for subsequent automated processing such as refactoring and model-based verification. This paper presents an approach based on normalizing transformations of an input program and a pattern to find state machine implementations in the program and to extract relevant information. The results are used to create state machine models containing states, transitions, events, guards and actions. Fine-grained traceability between the model and the source code enables navigation and refactoring of model elements. We evaluate the approach by applying a prototypical implementation to industrial automotive embedded code and show that 74 % of the expected state machine implementations can be completely identified and 8 % partially.

A variety of algorithms and technologies exist to cope with design space exploration for software distribution in terms of real-time, embedded, multiprocessor, and mixed-critical systems. The automotive domain not only combines those domains but even introduces further constraints and requirements due to several design decisions, standards, or evolved methodologies. In addition, solutions are predominantly proprietary, often lack in perspicuity, and sophisticated approaches towards the comprehensive concern of constraints are rather rare. This paper presents typical constraints along with distributing automotive applications across the processing units of vehicles, outlines three software distribution methodologies based on the constraint programming paradigm, and evaluates those in comparison to related design space exploration approaches. Benchmarks upon hypothetical and industrial models show that the constraint-based approaches outperform other forms in many cases regarding quality and effectiveness. Additionally, the presented approach benefits from a holistic consideration of constraints such as processing unit affinities, safety level aggregations, communication costs as well as processing unit utilization optimization among others whilst being applicable to heterogeneous, networked, hierarchical, embedded, multi and many core architectures.

Model-driven software development using language workbenches like JetBrains MPS provide many advantages compared to traditional software development. Base languages can be incrementally extended to increase the abstractness up to domain-speciĄc languages (DSLs). Changes can be performed more efficiently in problem-oriented language extensions or DSLs, than in a base language. In addition, formal analysis can be performed on abstract models. To beneĄt from the model-driven approach, non-model-based legacy code has to be reusable and transformable to language extensions and DSLs. For the development of embedded systems, mbeddr provides a C99-like base language and extensions for MPS, such as mathematical symbols and state machines. This paper presents a case study that shows how many legacy C code fragments of three automotive series projects could be replaced by mbeddr language extensions. Furthermore, a proof of concept shows the feasibility of fraction and foreach loop refactorings. This work is a Ąrst approach for future language extension refactorings.

Distributing software effectively to multi core, many core, and distributed systems has been studied for decades but still advances successively driven by domain specific constraints. Programming vehicle ECUs is one of the most constrained domains that recently approached the need for concurrency due to advanced driver assistant systems or autonomous driving approaches. In this paper, software distribution challenges for such systems are discussed and solutions are presented for instruction precise modeling, affinity constrained distribution, and reducing task response times achieved by advanced software parallelization. Therefore, existing partitioning and mapping algorithms are advanced to consider affinity constraints, software component tags and communication costs. Our experiments along a remote controlled model car show that using our new advanced results instead of sequential implementations or software distributions provided by the operating system on a distributed heterogeneous system significantly improves its responsiveness in order to potentially reduce energy consumption and replaces error prone manual constraint considerations for mixed-critical applications.

The increasing amount of innovative software technologies in the automotive domain comes with challenges regarding inevitable distributed multi-core and many-core methodologies. Approaches for general purpose solutions have been studied over decades but do not completely meet the specific constraints (e. g. timing, safety, reliability, affinity, etc.) for Autosar compliant applications. Autosar utilizes a spinlock mechanism in combination with the priority ceiling protocol in order to provide mutually exclusive access to shared resources. The essential disadvantages of spinlocks are unpredictable task response times on the one hand and wasted computation time caused by busy waiting periods on the other hand. In this paper, we propose a concept of task-release-delta-based runnable reordering for the purpose of sequentializing parallel accesses to shared resources, resulting in reduced task response times, improved timing predictability, and increased parallel efficiency respectively. To achieve this, runnables that represent smallest executable program parts in Autosar are reordered based on precedence constraints. Our experiments among industrial use cases show that task response times can be reduced by up to 18,2%.

Software Development for Automotive Systems is becoming more and more complex. Cars are turned into software intensive and to some extent software defined products by the increasing functionality of the various electronic control units (ECUs). Major driving factors for this development are complex human-machine-interfaces (HMI), eMobility and autonomous driving. Consequently, developing the software comes along with complex development projects and several partners. Different companies participate in such projects and form a value chain for the generation of a certain software system. Development tools have to support these project specific value chains. For this purpose the tools form a project-specific information supply chain. Ideally, they are connected to an automated tool chain. AMALTHEA provides an open source tool chain platform to support the setup of project specific development systems. This contribution presents the AMALTHEA tool chain environment and the underlying software development methodology. The concepts for the support of tailoring a tool chain and the standardization activities for the respective framework are described. Furthermore, an approach for the quantification of the efficiency and effectivity gains is described and key performance indicators are estimated.

This paper introduces novel approaches to partitioning and mapping in terms of model-based embedded multicore system engineering and further discusses benefits, industrial relevance and features in common with existing approaches. In order to assess and evaluate results, both approaches have been applied to a real industrial application as well as to various prototypical demonstrative applications, that have been developed and implemented for different purposes. Evaluations show, that such applications improve significantly according to performance, energy efficiency, meeting timing constraints and covering maintaining issues by using the AMALTHEA platform and the implemented approaches. Furthermore, the model-based design provides an open, expandable, platform independent and scalable exchange format between OEMs, suppliers and developers on different levels. Our proposed mechanisms provide meaningful multicore system utilization since load balancing by means of partitioning and mapping is effectively performed with regard to the modeled systems including hardware, software, operating system, scheduling, constraints, configuration and more data. Keywords—Partitioning, mapping, distributed systems, scheduling,

Tracing is an inevitable concept for assessing system behavior and optimizing resource utilization in parallel embedded real-time architectures. In the last decades, tracing and trace-recording analysis gained increasing importance due to more complex, computation intense and especially parallel applications spread across a variety of domains. Safety requirements, load balancing, effective memory utilization, product line engineering, heterogeneous targets or demands of common standards are just some of the occurring challenges. Our work addresses iterative system augmentation among models, performance-optimizing features and tracing in order to increase system performance and allow advanced analysis processes. Along with this automatic approach, development results benefit from lower costs and efforts, optimized parallelization, more effective resource utilization and reduced time-to-markets. By replacing a chain of different tools and corresponding manual data transformation and data adaptation with our iterative and comprehensive concept, we provide an advanced, integrated and highly adaptable solution for embedded system development. Furthermore, we illustrate the utilization of vector clocks instead of timestamps for process synchronization and trace analysis. Causal order determination as well as constraint derivation are described among examples and benefits are outlined correspondingly.

Although robotic systems with a high amount of actuators, sensors and software-algorithms involve software development that is usually not trivial, model-based methods are rarely used. This paper presents the entire workflow, supporting the development steps from concept specifications to implementation of distributed robotic system, which are developed model-based with Matlab/ Simulink. Different ARM based target platforms, such as the Raspberry Pi, the robot RobotinoXT, Kinect and SensorTag to realize sensors, actuators and a particle filter are used. The distributed system that consist of four computers is modelled in four Simulink models. The communication with each other and with the components takes places via UDP. The implementation of a preprocessing for the integration of the components and the development of Simulink blocks is necessary. This paper presents and evaluates the distributed approach in robotic systems, as well as its development with Matlab/ Simulink.

[Context/ Motivation] A smart device is a software-intensive system that operates autonomously and interacts to some degree with other systems over wireless connections. Such systems are often faced with uncertainty in the environment. Runtime representations of requirements have recently gained more interested to deal with this challenge and the term requirements at runtime has been established. Runtime representations of requirements support reasoning about the requirements at runtime and adapting the configuration of a system according to changes in the environment. [Questions/Problems] The research question is how the results of runtime monitoring of requirements and the system’s decisions about changes in the configuration are communicated back to the requirements engineer to better understand the environment. There is a gap between the written requirements document and the dynamic requirements model inside the system. This problem is exacerbated by the fact that a requirements document are mostly informal while the dynamic requirements model is formal. [Principal ideas/results] This paper introduces an approach to bridge the gap between development time and runtime representations of requirements in order to keep them consistent and to facilitate better understanding. We propose to weave the feedback from the runtime system into requirements documents using a domain-specific language that largely retain the informal nature of requirements. An annotated requirements document helps get a better understanding of the system’s actual behavior in a given environment. The approach is implemented using mbeddr, a novel set of domain-specific languages for developing embedded systems, and illustrated using a running example.

Academic research is promoting the free mind. The intention is to discover new findings in early phases of the innovation process. The researchers consider their creativity to be dependent on freedom and openness. Nevertheless, today’s research institutions are large and many of them conduct a business projects requiring a constant flow of projects and results. The challenge is to use professional innovation processes without destroying creativity and freedom. Ideas need to have a chance to result into a research project and scientists need to be protected from too much administration. Innovation processes for academic research need to be lean, simple, efficient and effective. This paper presents processes and tools for the early phase of transferring an innovative idea into a funding project. They are based on an IT platform which allows web based access from any place at any time. Results from the application in a research group are evaluated.

Tracking, partitioning and tracing in modern dynamic high performance computing systems are three of the most innovative and important development aspects for performance optimization purposes and state-of-the-art advanced quality. This paper discusses these three aspects with respect to distributed systems and proposes new mechanisms for an advanced utilization of software in this domain. We present a specific tracking mechanism via vector clocks for model and code partitioning purposes and the determination of causality relations. Further, a tracing approach for an effective analysis and thereby utilization of code and the corresponding architecture is introduced. The combination of both approaches leads to a high degree of parallelism and a fine-grained structure of execution units, that further traced, supports a precise analysis of synchronous and asynchronous system’s behavior as well as an optimal load balancing. The mechanisms are introduced with respect to a model based control engineering tool and event diagrams.

Tracking, partitioning and tracing in modern dynamic high performance computing systems are three of the most innovative and important development aspects for performance optimization purposes and state-of-the-art advanced quality. This paper discusses these three aspects with respect to distributed systems and proposes new mechanisms for an advanced utilization of software in this domain. We present a specific tracking mechanism via vector clocks for model and code partitioning purposes and the determination of causality relations. Further, a tracing approach for an effective analysis and thereby utilization of code and the corresponding architecture is introduced. The combination of both approaches leads to a high degree of parallelism and a fine-grained structure of execution units, that further traced, supports a precise analysis of synchronous and asynchronous system's behavior as well as an optimal load balancing. The mechanisms are introduced with respect to a model based control engineering tool and event diagrams.

Academic research is promoting the free mind of the genius. The intention is to discover ground breaking findings in very early phases of the innovation process. The researchers consider their creativity to be dependent on freedom and openness. Nevertheless, today's scientific landscape is a bit different from this. Research institutions are large and many of them conduct project business. Research projects need to be planned in a professional way, research outcomes need to be achieved. A more or less professional innovation process has to guarantee a constant flow of projects and results. This is not only mandatory to finance the work of the research institution, but also due to the expectations of the society towards science. The challenge is to use professional innovation processes without destroying creativity and freedom. Ideas need to have a chance to result into a research project and a respective innovative finding. Scientists need to be protected from too much administration and restrictions. Therefore, innovation processes for academic research need to be lean, simple, efficient and effective. This paper presents ideas for such processes and tools. The focus is the early phase of transferring an innovative idea into a funding project. Results and experiences from the application in a research group focusing on applied engineering sciences are evaluated.

This paper presents a new approach to enhance speech based on a distributed microphone network. Each microphone is used to simultaneously classify the input into either one of the noise types or as speech. For enhancing the speech signal a modified spectral subtraction approach is used that utilize the sound information of the entire network to update the noise model even during speech. This improves the reduction of the ambient noise, especially for non-stationary noise types such as street or beach noise. Experiments demonstrate the effectiveness of the proposed system.

We present a new approach for speech enhancement in the presence of non-stationary and rapidly changing background noise. A distributed microphone system is used to capture the acoustic characteristics of the environment. The input of each microphone is then classified either as speech or one of the predetermined noise types. Further enhancement of speech in respective microphones is carried out using a modified spectral subtraction algorithm that incorporates multiple noise models to quickly adapt to rapid background noise changes. Tests on real world speech captured under diverse conditions demonstrate the effectiveness of this method.

We show the integration of the three concepts of channel/agency-nets, functional programming and production rules into one uniform language for the executable specification of communicating production systems using a distributed version of the well known Towers of Hanoi problem as a sample application. The distributed active and passive components of a channel/agency-net are modelled based on a system view according to Backus' applicative state transition systems. For the description of complex state transitions the functional subsystem is extended by language features for specifying production rules. Having implemented a virtual machine we are able to run such specifications on a computer and observe the system's behaviour.