42, A Component-Based Approach to Virtual Prototyping of Heterogeneous Embedded Systems. (42, Une Approche à Composants pour le Prototypage Virtuel des Systèmes Embarqués Hétérogènes)

The work presented in this thesis deals with virtual prototyping of heterogeneous embedded systems. The complexity of these systems make it difficult to find an optimal solution. Hence, engineers usually make simulations that require virtual prototyping of the system. Virtual prototyping of an embedded system aims at providing an executable model of it, in order to study its functional as well as its non-functional aspects. Our contribution is the definition of a new component-based approach for the virtual prototyping of embedded systems, called 42. 42 is not a new language for the design of embedded systems, it is a tool for describing components and assemblies for embedded systems at the system-level. Virtual prototyping of embedded systems must take into account their heterogeneous aspect. Following Ptolemy, several approaches propose a catalog of MoCCs (Models of Computation and Communication) and a framework for hierarchically combining them in order to model heterogeneity. As in Ptolemy, 42 allows to organize components and MoCCs in hierarchy. However, the MoCCs in 42 are described by means of programs manipulating a small set of basic primitives to activate components and to manage their communication. A component-based approach like 42 requires a formalism for specifying components. 42 proposes several means for specifying components. We will present these means an give particular interest to 42 control contracts. 42 is designed independently from any language or formalism and may be used jointly with the existing approaches. We provide a proof of concept to demonstrate the interest of using 42 and its control contracts with the existing approaches.

[1]  Joseph Sifakis,et al.  Modeling Heterogeneous Real-time Components in BIP , 2006, Fourth IEEE International Conference on Software Engineering and Formal Methods (SEFM'06).

[2]  R. Kramer iContract - The Java(tm) Design by Contract(tm) Tool , 1998 .

[3]  Bertrand Meyer,et al.  Object-Oriented Software Construction, 2nd Edition , 1997 .

[4]  Patrice Godefroid,et al.  Model checking for programming languages using VeriSoft , 1997, POPL '97.

[5]  Wang Yi,et al.  Uppaal in a nutshell , 1997, International Journal on Software Tools for Technology Transfer.

[6]  Bertrand Meyer,et al.  Applying 'design by contract' , 1992, Computer.

[7]  Julia L. Lawall,et al.  Proceedings of the 2002 Usenix Annual Technical Conference Think: a Software Framework for Component-based Operating System Kernels , 2022 .

[8]  Florence Maraninchi,et al.  Argos: an automaton-based synchronous language , 2001, Comput. Lang..

[9]  gonnord Laure Danthony Accélération abstraite pour l'amélioration de la précision en Analyse des Relations Linéaires , 2007 .

[10]  Frédéric Boulanger,et al.  ModHel'X: A Component-Oriented Approach to Multi-Formalism Modeling , 2008, MoDELS.

[11]  Stephen N. Freund,et al.  FastTrack: efficient and precise dynamic race detection , 2009, PLDI '09.

[12]  Naranker Dulay,et al.  Regis: a constructive development environment for distributed programs , 1994, Distributed Syst. Eng..

[13]  Srinivas Devadas Optimizing interacting finite state machines using sequential don't cares , 1991, IEEE Trans. Comput. Aided Des. Integr. Circuits Syst..

[14]  Florence Maraninchi,et al.  A Method for the Efficient Development of Timed and Untimed Transaction-Level Models of Systems-on-Chip , 2008, 2008 Design, Automation and Test in Europe.

[15]  Nicholas Carriero,et al.  Linda and Friends , 1986, Computer.

[16]  Nicolas Halbwachs,et al.  Programming and Verifying Real-Time Systems by Means of the Synchronous Data-Flow Language LUSTRE , 1992, IEEE Trans. Software Eng..

[17]  Mario Banville SONIA: An Adaptation of LINDA for Coordination of Activities in Organisations , 1996, COORDINATION.

[18]  N. Halbwachs,et al.  Programming and verifying critical systems by means of the synchronous data-flow language LUSTRE , 1991, SIGSOFT '91.

[19]  Jean-Marc Jézéquel,et al.  Design by Contract: The Lessons of Ariane , 1997, Computer.

[20]  Florence Maraninchi,et al.  Contract-Based Coordination of Hardware Components for the Development of Embedded Software , 2009, COORDINATION.

[21]  Tim Weilkiens,et al.  Systems engineering with SysML / UML - modeling, analysis, design , 2007 .

[22]  Didier Donsez,et al.  Towards a Reference Model for Implementing the Fractal Specifications for Java and the .NET Platform , 2006 .

[23]  Bradley R. Schmerl,et al.  Modeling and implementing software architecture with Acme and ArchJava , 2005, Proceedings. 27th International Conference on Software Engineering, 2005. ICSE 2005..

[24]  François Pêcheux,et al.  Modeling and Refining Heterogeneous Systems With SystemC-AMS: Application to WSN , 2008, 2008 Design, Automation and Test in Europe.

[25]  Sriram K. Rajamani,et al.  The SLAM project: debugging system software via static analysis , 2002, POPL '02.

[26]  Olivier Ponsini,et al.  A Schedulerless Semantics of TLM Models Written in SystemC Via Translation into LOTOS , 2008, FM.

[27]  Charles André,et al.  Computing SyncCharts Reactions , 2004, SLAP.

[28]  Grigore Rosu,et al.  Java-MOP: A Monitoring Oriented Programming Environment for Java , 2005, TACAS.

[29]  Mudit Goel,et al.  Process Networks in Ptolemy II , 1998 .

[30]  Thomas Ringler,et al.  Static Worst-Case Execution Time Analysis of Synchronous Programs , 2000, Ada-Europe.

[31]  A. Hugo A Hardware Implementation of Pure Esterel , 1991 .

[32]  Nicholas Carriero,et al.  Linda in context , 1989, CACM.

[33]  Nicolas Halbwachs,et al.  Combining Widening and Acceleration in Linear Relation Analysis , 2006, SAS.

[34]  Shmuel Sagiv,et al.  TVLA: A System for Implementing Static Analyses , 2000, SAS.

[35]  Luciano Lavagno,et al.  Metropolis: An Integrated Electronic System Design Environment , 2003, Computer.

[36]  Christel Baier,et al.  Modeling component connectors in Reo by constraint automata , 2004, Sci. Comput. Program..

[37]  Nancy A. Lynch,et al.  Hierarchical correctness proofs for distributed algorithms , 1987, PODC '87.

[38]  Farhad Arbab,et al.  Web services choreography and orchestration in Reo and constraint automata , 2007, SAC '07.

[39]  J. Cornet,et al.  SystemC/TLM semantics for heterogeneous system-on-chip validation , 2008, 2008 Joint 6th International IEEE Northeast Workshop on Circuits and Systems and TAISA Conference.

[40]  Srinivas Devadas,et al.  Redundancies and don't cares in sequential logic synthesis , 1989, Proceedings. 'Meeting the Tests of Time'., International Test Conference.

[41]  Frantisek Plasil,et al.  Behavior Protocols for Software Components , 2002, IEEE Trans. Software Eng..

[42]  Nicolas Halbwachs,et al.  Discovering properties about arrays in simple programs , 2008, PLDI '08.

[43]  Thomas A. Henzinger,et al.  Reactive Modules , 1999, Formal Methods Syst. Des..

[44]  Edward A. Lee Modeling concurrent real-time processes using discrete events , 1999, Ann. Softw. Eng..

[45]  Nicolas Halbwachs,et al.  Implementing Reactive Programs on Circuits: A Hardware Implementation of LUSTRE , 1991, REX Workshop.

[46]  Edward A. Lee,et al.  Leveraging synchronous language principles for heterogeneous modeling and design of embedded systems , 2007, EMSOFT '07.

[47]  Paul Le Guernic,et al.  SIGNAL: A declarative language for synchronous programming of real-time systems , 1987, FPCA.

[48]  Jean-Philippe Babau,et al.  Qinna, a component-based qos architecture , 2005, CBSE'05.

[49]  Nicolas Halbwachs,et al.  Synchronous Programming of Reactive Systems , 1992, CAV.

[50]  Gérard Berry,et al.  The Esterel Synchronous Programming Language: Design, Semantics, Implementation , 1992, Sci. Comput. Program..

[51]  Koushik Sen,et al.  A randomized dynamic program analysis technique for detecting real deadlocks , 2009, PLDI '09.

[52]  Florence Maraninchi Computational Modeling of Non-Functional Properties with the Component Model 42 , 2008 .

[53]  Rance Cleaveland,et al.  Architectural interaction diagrams: AIDs for system modeling , 2003, 25th International Conference on Software Engineering, 2003. Proceedings..

[54]  Stephen A. Edwards,et al.  The synchronous languages 12 years later , 2003, Proc. IEEE.

[55]  Axel Legay,et al.  Modal interfaces: unifying interface automata and modal specifications , 2009, EMSOFT '09.

[56]  A. B. Kahn,et al.  Topological sorting of large networks , 1962, CACM.

[57]  Marc Pouzet,et al.  Modular static scheduling of synchronous data-flow networks: an efficient symbolic representation , 2009, EMSOFT '09.

[58]  Edward A. Lee,et al.  Taming heterogeneity - the Ptolemy approach , 2003, Proc. IEEE.

[59]  Florence Maraninchi,et al.  Formal and executable contracts for transaction-level modeling in SystemC , 2009, EMSOFT '09.

[60]  Johan Lilius,et al.  A language for multiple models of computation , 2002, Proceedings of the Tenth International Symposium on Hardware/Software Codesign. CODES 2002 (IEEE Cat. No.02TH8627).

[61]  Florence Maraninchi,et al.  Automatic Generation of Schedulings for Improving the Test Coverage of Systems-on-a-Chip , 2006, 2006 Formal Methods in Computer Aided Design.

[62]  Mario Südholt,et al.  On Components with Explicit Protocols Satisfying a Notion of Correctness by Construction , 2002, CoopIS/DOA/ODBASE.

[63]  Pascal Raymond,et al.  The synchronous data flow programming language LUSTRE , 1991, Proc. IEEE.

[64]  Farhad Arbab,et al.  Reo: A Channel-based Coordination Model for Component Composition , 2005 .

[65]  P. Le Guernic,et al.  Hybrid dynamical systems theory and the Signal language , 1990 .

[66]  Alberto L. Sangiovanni-Vincentelli,et al.  Tag machines , 2005, EMSOFT.

[67]  Matthieu Moy,et al.  Arrival Curves for Real-Time Calculus: The Causality Problem and Its Solutions , 2010, TACAS.

[68]  Abdoulaye Gamatié,et al.  Synchronous modeling of avionics applications using the SIGNAL language , 2003, The 9th IEEE Real-Time and Embedded Technology and Applications Symposium, 2003. Proceedings..

[69]  Anneke Kleppe,et al.  The Object Constraint Language: Getting Your Models Ready for MDA , 2003 .

[70]  Jean-Marc Jézéquel,et al.  Making Components Contract Aware , 1999, Computer.

[71]  Patrick Cousot,et al.  A static analyzer for large safety-critical software , 2003, PLDI '03.

[72]  Nicolas Halbwachs,et al.  Synchronous Modelling of Asynchronous Systems , 2002, EMSOFT.

[73]  Edward A. Lee,et al.  CONTINUOUS TIME AND MIXED-SIGNAL SIMULATION IN PTOLEMY II , 1999 .

[74]  Edward A. Lee,et al.  Heterogeneous composition of models of computation , 2009, Future Gener. Comput. Syst..

[75]  Gerard J. Holzmann,et al.  The State of SPIN , 1996, CAV.

[76]  Kenneth L. McMillan,et al.  The SMV System , 1993 .

[77]  Marc Pouzet,et al.  N-synchronous Kahn networks: a relaxed model of synchrony for real-time systems , 2006, POPL '06.

[78]  Paul Caspi,et al.  About the Design of Distributed Control Systems: The Quasi-Synchronous Approach , 2001, SAFECOMP.

[79]  Kenneth L. McMillan,et al.  Symbolic model checking: an approach to the state explosion problem , 1992 .

[80]  Patrick Cousot,et al.  Static determination of dynamic properties of programs , 1976 .

[81]  Robert Tolksdorf Coordinating Services in Open Distributed Systems with LAURA , 1996, COORDINATION.

[82]  Frantisek Plasil,et al.  SOFA/DCUP: architecture for component trading and dynamic updating , 1998, Proceedings. Fourth International Conference on Configurable Distributed Systems (Cat. No.98EX159).

[83]  Kim G. Larsen,et al.  Modal Specifications , 1989, Automatic Verification Methods for Finite State Systems.

[84]  Florence Maraninchi,et al.  GLONEMO: global and accurate formal models for the analysis of ad-hoc sensor networks , 2006, InterSense '06.

[85]  Florence Maraninchi,et al.  Pinapa: an extraction tool for SystemC descriptions of systems-on-a-chip , 2005, EMSOFT.

[86]  Robin Milner,et al.  A Calculus of Communicating Systems , 1980, Lecture Notes in Computer Science.

[87]  Marc Pouzet,et al.  Synchronization of periodic clocks , 2005, EMSOFT.

[88]  Nicolas Halbwachs,et al.  Virtual execution of AADL models via a translation into synchronous programs , 2007, EMSOFT '07.

[89]  Gilles Kahn,et al.  Coroutines and Networks of Parallel Processes , 1977, IFIP Congress.

[90]  Florence Maraninchi,et al.  LusSy: a toolbox for the analysis of systems-on-a-chip at the transactional level , 2005, Fifth International Conference on Application of Concurrency to System Design (ACSD'05).

[91]  C. A. R. Hoare,et al.  Communicating sequential processes , 1978, CACM.

[92]  Nicolas Halbwachs,et al.  LUSTRE: a declarative language for real-time programming , 1987, POPL '87.

[93]  Frank Ghenassia Transaction-Level Modeling with SystemC: TLM Concepts and Applications for Embedded Systems , 2010 .

[94]  Edward A. Lee,et al.  Operational Semantics of Hybrid Systems , 2005, HSCC.

[95]  Thierry Coupaye,et al.  The FRACTAL component model and its support in Java , 2006, Softw. Pract. Exp..

[96]  Giovanni De Micheli,et al.  Don't care set specifications in combinational and synchronous logic circuits , 1993, IEEE Trans. Comput. Aided Des. Integr. Circuits Syst..

[97]  Patrick Cousot,et al.  Abstract interpretation: a unified lattice model for static analysis of programs by construction or approximation of fixpoints , 1977, POPL.

[98]  Nicolas Halbwachs,et al.  Simulation and Verification of Asynchronous Systems by means of a Synchronous Model , 2006, ACSD.

[99]  Amir Pnueli,et al.  The temporal logic of programs , 1977, 18th Annual Symposium on Foundations of Computer Science (sfcs 1977).

[100]  Daniel D. Gajski,et al.  SPECC: Specification Language and Methodology , 2000 .

[101]  Paula Herber,et al.  Model checking SystemC designs using timed automata , 2008, CODES+ISSS '08.

[102]  Robin Milner,et al.  Calculi for Synchrony and Asynchrony , 1983, Theor. Comput. Sci..

[103]  Jan van den Bos,et al.  PROCOL - A Parallel Object Language with Protocols , 1989, OOPSLA.

[104]  Patrick Cousot,et al.  Types as abstract interpretations , 1997, POPL '97.

[105]  Daniel Brand,et al.  Don't cares in synthesis: theoretical pitfalls and practical solutions , 1998, IEEE Trans. Comput. Aided Des. Integr. Circuits Syst..

[106]  Gerard J. Holzmann,et al.  The Model Checker SPIN , 1997, IEEE Trans. Software Eng..

[107]  Christian Haubelt,et al.  Formalizing TLM with Communicating State Machines , 2006, FDL.

[108]  Thierry Coupaye,et al.  The FRACTAL component model and its support in Java: Experiences with Auto-adaptive and Reconfigurable Systems , 2006 .

[109]  Joseph Sifakis,et al.  Specification and verification of concurrent systems in CESAR , 1982, Symposium on Programming.

[110]  Gilles Kahn,et al.  The Semantics of a Simple Language for Parallel Programming , 1974, IFIP Congress.

[111]  Antonio Vallecillo,et al.  Typing the Behavior of Software Components using Session Types , 2006, Fundam. Informaticae.

[112]  Florence Maraninchi,et al.  42: programmable models of computation for a component-based approach to heterogeneous embedded systems , 2007, GPCE '07.

[113]  Thomas E. Cheatham,et al.  A Suite of Analysis Tools Based on a General Purpose Abstract Interpreter , 1994, CC.

[114]  Michael Burrows,et al.  Eraser: a dynamic data race detector for multithreaded programs , 1997, TOCS.

[115]  Axel Jantsch,et al.  Modeling embedded systems and SoCs - concurrency and time in models of computation , 2003, The Morgan Kaufmann series in systems on silicon.

[116]  Mary Shaw,et al.  Abstractions for Software Architecture and Tools to Support Them , 1995, IEEE Trans. Software Eng..

[117]  Alain Girault,et al.  Sur la répartition de programmes synchrones , 1994 .

[118]  Nicolas Halbwachs,et al.  Synchronous Observers and the Verification of Reactive Systems , 1993, AMAST.

[119]  Steve Vestal,et al.  An Overview of the SAE Architecture Analysis & Design Language (AADL) Standard: A Basis for Model-Based Architecture-Driven Embedded Systems Engineering , 2004, IFIP-WADL.

[120]  Miltos D. Grammatikakis,et al.  OCCN: a network-on-chip modeling and simulation framework , 2004, Proceedings Design, Automation and Test in Europe Conference and Exhibition.

[121]  Thomas A. Henzinger,et al.  Interface automata , 2001, ESEC/FSE-9.

[122]  Yanhong Liu,et al.  Performance Evaluation of Components Using a Granularity-based Interface Between Real-Time Calculus and Timed Automata , 2010, QAPL.

[123]  Farhad Arbab,et al.  Coordination Models and Languages , 1998, Adv. Comput..

[124]  Carl Hewitt,et al.  A Universal Modular ACTOR Formalism for Artificial Intelligence , 1973, IJCAI.

[125]  Edmund M. Clarke,et al.  Model Checking , 1999, Handbook of Automated Reasoning.