Model Driven Engineering for Distributed Real-Time Embedded Systems 2009 E-Book

• Herausgeber: John Wiley & Sons
• Kategorie: Wissenschaft und neue Technologien
• Sprache: Englisch

Seitenzahl: 287

Veröffentlichungsjahr: 2013

Beschreibung

Model-based development methods, and supporting technologies, can provide the techniques and tools needed to address the dilemma between reducing system development costs and time, and developing increasingly complex systems. This book provides the information needed to understand and apply model-drive engineering (MDE) and model-drive architecture (MDA) approaches to the development of embedded systems. Chapters, written by experts from academia and industry, cover topics relating to MDE practices and methods, as well as emerging MDE technologies. Much of the writing is based on the presentations given at the Summer School "MDE for Embedded Systems" held at Brest, France, in September 2004.

Leseprobe

Table of Contents

Chapter Summary

Chapter 1: Model Transformation: A Survey of the State of the Art

1.1. Model-driven engineering

1.2. Model transformation

1.3. Model transformation languages

1.4. Model transformation activities

1.5. Conclusion

1.6. Acknowledgements

1.7. Bibliography

Chapter 2: Model-Based Code Generation

2.1. Introduction

2.2. The model-driven architecture (MBA) process

2.3. The automated approach to code generation

2.4. Domain modeling

2.5. The executable UML (xUML) formalism

2.6. System generation

2.7. Executable UML to code mappings

2.8. Conclusions

2.9. Bibliography

Chapter 3: Testing Model Transformations: A Case for Test Generation from Input Domain Models

3.1. Introduction

3.2. Challenges for testing systems with large input domains

3.3. Selecting test data in large domains

3.4. Metamodel-based test input generation

3.5. Conclusion

3.6. Acknowledgements

3.7. Bibliography

Chapter 4: Symbolic Execution-Based Techniques for Conformance Testing

4.1. Context

4.2. Input output symbolic transition systems

4.3. Symbolic execution

4.4. Conformance testing for IOSTS

4.5. Concluding remarks

4.6. Bibliography

Chapter 5: Using MARTE and SysML for Modeling Real-Time Embedded Systems

5.1. Introduction

5.2. Background

5.3. Scenarios of combined usage

5.4. Combination Strategies

5.5. Related work

5.6. Conclusion

5.7. Acknowledgements

5.8. Bibliography

Chapter 6: Software Model-Based Performance Analysis

6.1. Introduction

6.2. Performance models

6.3. Software model with performance annotations

6.4. Mapping from software to performance model

6.5. Using a pivot language: Core Scenario Model (CSM)

6.6. Case study performance model

6.7. Conclusions

6.8. Acknowledgements

6.9. Bibliography

Chapter 7: Model Integration for Formal Qualification of Timing-Aware Software Data Acquisition Components

7.1. Introduction

7.2. System modeling

7.3. Variation points modeling

7.4. Experiments and results

7.5. Conclusion

7.6. Bibliography

Chapter 8: SoC/SoPC Development using MDD and MARTE Profile

8.1. Introduction

8.2. Related works

8.3. MOPCOM process and models

8.4. Application

8.5. System analysis

8.6. Abstract modeling level

8.7. Execution modeling level

8.8. Detailed modeling level

8.9. Tooling Support

8.10. HDL Code Generation

8.11. Conclusion

8.12. Acknowledgements

8.13. Bibliography

List of Authors

Index

First published 2010 in Great Britain and the United States by ISTE Ltd and John Wiley & Sons, Inc.

Apart from any fair dealing for the purposes of research or private study, or criticism or review, as permitted under the Copyright, Designs and Patents Act 1988, this publication may only be reproduced, stored or transmitted, in any form or by any means, with the prior permission in writing of the publishers, or in the case of reprographic reproduction in accordance with the terms and licenses issued by the CLA. Enquiries concerning reproduction outside these terms should be sent to the publishers at the undermentioned address:

ISTE Ltd27-37 St George’s RoadLondon SW19 4EUUKJohn Wiley & Sons, Inc.111 River StreetHoboken, NJ 07030USAwww.iste.co.ukwww.wiley.com

© ISTE Ltd 2010

The rights of Jean-Philippe Babau, Mireille Blay-Fornarino, Joël Champeau, Sylvain Robert and Antonio Sabetta to be identified as the authors of this work have been asserted by them in accordance with the Copyright, Designs and Patents Act 1988.

Library of Congress Cataloging-in-Publication Data

Model-driven engineering for distributed real-time systems : MARTE modeling, model transformations, and their usages / edited by Jean-Philippe Babau… [et al.].

p. cm.

Includes bibliographical references and index.

ISBN 978-1-84821-115-5

1. Model-driven software architecture. 2. Electronic data processing--Distributed processing. 3. Real-time data processing. 4. UML (Computer science). I. Babau, Jean-Philippe.

QA76.76.D47M622 2010

005.2'732--dc22

2010027955

British Library Cataloguing-in-Publication Data

A CIP record for this book is available from the British Library ISBN

978-1-84821-115-5

Chapter Summary

Chapter 1

Model-driven engineering (MDE) is an approach to software development where the primary focus is on models, as opposed to source code. The use of models opens up new possibilities for creating, analyzing, manipulating and formally reasoning about systems at a high level of abstraction.

To reap all the benefits of MDE, it is essential to install a model transformation mechanism, that enables a wide range of different automated activities such as translation of models (expressed in different modeling languages), generating code from models, model synthesis, model improvement, model verification and model simulation. To achieve this, languages, formalisms, techniques, processes, tools and standards that support model transformation are needed. This chapter surveys the state of the art of model transformation, and discusses how it can be used to support some essential activities in MDE.

Chapter 2

This chapter explains how the combination of the OMG’s Model-Driven architecture (MDA) process and the executable UML formalism can be used to specify and build embedded software systems. It will deal specifically with:

– the Model-Driven Architecture principle of partitioning a system into domains for which we construct Platform Independent Models (PIMs);

– the use of Executable UML (xUML) for the construction of precise, complete PIMs that can be demonstrated and verified prior to implementation;

– automatic translation of the PIMs into Platform Specific Models (PSMs) and then into performance compliant code running on an embedded target.

Chapter 3

Model transformations can automate critical tasks in model-driven development. Thorough validation techniques are required to ensure their correctness. In this chapter we focus on testing model transformations. In particular, we present an approach for the systematic selection of input test data. This approach is based on a key characteristic of model transformations: their input domain is formally captured in a metamodel. A major challenge for test generation is that metamodels usually model an infinite set of possible input models for the transformation.

We start with a general motivation of the need for specific test selection techniques in the presence of very large and possibly infinite input domains. We also present two existing black-box strategies to systematically select test data: category-partition and combinatorial interaction testing. Then, we detail specific criteria based on metamodel coverage to select data for model transformation testing. We introduce object and model fragments to capture specific structural constraints that should be satisfied by input test data. These fragments are the basis for the definition of coverage criteria and for the automatic generation of test data. They also serve to drive the automatic generation of models for testing.

Chapter 4

In this chapter we discuss techniques to test whether a system conforms to its model given in terms of an Input/Output Symbolic Transition System (IOSTS). IOSTSs are automata-based models using data types to enrich transitions with data-based messages and guards depending on state variables. We focus on symbolic execution techniques both to extract IOSTS behaviors to be tested in the role of test purposes and to ground test case generation.

Chapter 5

Using model-based approaches for designing embedded systems helps remove unnecessary details in a manner that reduces production costs, increases the potential for easy validation and verification, and facilitates reuse and evolution. In this context, a common practice is to use UML as the base language, possibly specialized by the so-called profiles. Despite the ever increasing number of profiles being built in many domains, there is still insufficient focus on discussing the issue of combining multiple profiles. Indeed, a single profile may not be adequate to cover all aspects required in the multidisciplinary domain of embedded systems.

In this chapter, we assess possible strategies for combining the SysML and MARTE profiles in a common modeling framework, while avoiding specification conflicts. We show that, despite some semantic and syntactical overlapping, the two are highly complementary for specifying embedded systems at different abstraction levels. We conclude, however, that a convergence agenda is highly desirable to ensure proper alignment of some key language features.

Chapter 6

This chapter starts with a brief review of performance modeling formalisms and a discussion of the performance annotations that need to be added to UML software models in order to enable performance analysis. The principles for transforming annotated software models into performance models are then presented. Such model transformations must bridge a large semantic gap between the source and the target model; hence a pivot model is often used. An example of such a transformation is given, from UML extended with the MARTE profile to the Layered Queueing Network performance model. The role of an intermediate pivot language called Core Scenario Model is also discussed. The chapter ends with a discussion of the lessons learned and future challenges for integrating the analysis of multiple non-functional properties in the context of MDE.

Chapter 7

This chapter proposes to integrate design and formal modeling approaches, based on MARTE, IF and CDL, to evaluate different possible uses and configurations of a data acquisition software component. The uses are related to the actor’s (sensor and application) behavior and configurations are related to implementation parameterization. Evaluation considers safety and performance properties and delay evaluation, which are automatically evaluated by the OBP tool. The work is illustrated using an example to show the impact of parameters and contextual use on software acquisition driver performances. Using this tool, it is possible to tune the driver’s parameters to obtain the required performances, in terms of delays, for a certain context use. The approach is applied to sensor monitoring applications.

Chapter 8

This chapter presents a new methodology for developing SoC/SoPC applications. This methodology is based on UML and MDD and capitalizes on the achievements of the “Electronic System Level” community by taking into account the new MARTE profile dedicated to real-time embedded systems. In the MOPCOM SoC/SoPC research project, a tooling has been developed to support this SoC/SoPC methodology, the MARTE profile, HDL code generation and documentation generation. A Cognitive Radio demonstrator is presented to illustrate the methodology and the tooling.

Chapter 1

Model Transformation: A Survey of the State of the Art1

Rien ne se perd, rien ne se crée, tout se transforme. (Nothing is lost, nothing is created, everything is transformed) Antoine-Laurent de Lavoisier (1743-1794)

1.1. Model-driven engineering

Model-Driven Engineering (MDE) is an approach to software development where the principle artefacts are models (as opposed to source code). It is a natural next step in the evolution of software development to continue to raise the level of abstraction in order to tackle increasingly complex problems. The main goal is to reduce the accidental complexity [BRO 86] of software, caused by the technology, methods and programming languages used to develop software. Of course, the essential complexity that is inherent to the problem to be solved cannot be reduced, no matter which approach, technology or language is adopted.

The basic principle behind MDE is that everything is a model. As such, it provides a generic approach to deal with all possible software artefacts used and produced during the software development life-cycle (e.g. requirement specifications, analysis and design documents, test suites, source code, and so on). Even the languages used to specify the models can be considered as models too, which are referred to as .