# Clock-directed Modular Code-generation for Synchronous Data-flow Languages

Save this PDF as:

Size: px
Start display at page:

## Transcription

1 1 Clock-directed Modular Code-generation for Synchronous Data-flow Languages Dariusz Biernacki Univ. of Worclaw (Poland) Jean-Louis Colaço Prover Technologies (France) Grégoire Hamon The MathWorks (USA) Marc Pouzet Université Paris-Sud (France) LCTES, Tucson June 13th, 2008

2 A certified compiler for Lustre Develop a certified compiler for synchronous block-diagram formalisms as found in SCADE/Lustre or a subset of Simulink with the help of the proof assistant Coq Very popular formalism for embedded software (and in particular critical systems) Existing certification: the existing SCADE compiler is qualified DO-178B (level A) this is mainly process-based : introduce more functional certification? this would allow to put more formal verification on the source code 2

3 3 Motivations (first step) Code generation from synchronous block-diagram has been addressed in the early 80 s and is part of folklore Nonetheless, a minimal and precise description of how code-generation is made in industrial compilers is missing First build a reference compiler, as small as possible, in (mostly) a purely functional way and based on local rewriting rules formalize the code generation into imperative sequential code (e.g., C) as small as possible but realistic (the code should be efficient) as a way to: build a certified compiler inside a proof assistant complement previous works on the extension/formalization of synchronous languages

4 Code Generation Principle: A stream function f : Stream(T ) Stream(T ) is compiled into a pair: an initial state and a transition function: s 0 : S, f t : S T T S a stream equation y = f(x) is computed sequentially by y n, s n+1 = f t (s n, x n ) An alternative (more general) solution: an initial state: s 0 : S a value function: f v : S T T a state modification ( commit ) function: f s : S T S Final remarks: this generalises to MIMO systems in actual implementations, states are modified in place synchrony finds a very practicle justification here: a data-flow can be implemented as a single scalar variable 4

5 5 Modular Code Generation produce a transition function for each block definition compose them together to produce the main transition function static scheduling following data-dependences But modular sequential code generation is not always feasible even in the absence of causality loops f (y, z) = f(t, y) This observation has led to two different approaches to the compilation problem

6 Two Traditional Approaches Non Modular Code Generation full static inlining before code generation starts enumeration techniques into (very efficient) automata ([Halbwachs et all., Raymond PhD. thesis, POPL 87, PLILP 91]) keeps maximal expressiveness but at the price of modular compilation and the size of the code may explode difficult to find the adequate boolean variables to get efficient code in both code and size Modular code generation mandatory in industrial compilers no preliminary inlining (unless requested by the user) imposes stronger causality constraints: every feedback loop must cross an explicit delay well accepted by SCADE users and justified by the need for tracability Between the two, it is possible to decompose a function into a minimal set of atomic functions (Raymond, 1988). 6

7 7 Proposal a compiler where everything can be traced with a precise semantics for every intermediate language introduce a basic clocked data-flow language as the input language general enough to be used as a input language for Lustre be a good input language for modern ones (e.g., mix of automata and data-flow as found in SCADE 6 or Simulink/StateFlow) provides a slightly more general notion of clocks and a reset construct compilation through an intermediate object based intermediate language to represent transition function provide a translation into imperative code (e.g., structured C, Java)

8 8 Organisation of the Compiler Static checking Translation EmitC ClockedFlowKernel Annotated DK OBL Structured C

9 9 Static Checking Type checking Clock checking CDK CDK+Types CDK+Types+Clocks Causality Check CDK+Types+Clocks Initialization Check CDK+Types+Clocks

10 A Clocked Data-flow Basic Language 10 A data-flow kernel where every expression is explicitely annotated with its clock a ::= e ct e ::= v x v fby a a when C(x) op (a,..., a) f (a,..., a) every a merge x (C a)... (C a) D ::= pat = a D and D pat ::= x (pat,..., pat) d ::= node f(p) = p with var p in D p ::= x : ty;...; x : ty v ::= C i ck ::= base ck on C(x) ct ::= ck ct... ct

11 Informal Semantics statically checked through a dedicated type system (clock calculus) 11 h True False True False... x x 0 x 1 x 2 x 3... y y 0 y 1 y 2 y 3... v fby x v x 0 x 1 x 2... x + y x 0 + y 0 x 1 + y 1 x 2 + y 2 x 3 + y 3... z = x when True(h) x 0 x 2... t = y when False(h) y 1 y 3... merge h (True z) (False t) x 0 y 1 x 2 y 3... z is at a slower rate than x. We say its clock is ck on True(h) the merge constructs needs its two arguments to be on complementary clocks

12 Derived Operators if x then e 2 else e 3 = merge x (True e 2 when True(x)) (False e 3 when False(x)) y = e 1 -> e 2 = y = if init then e 1 else e 2 and init = True fby False pre (e) = nil fby e Example (counter) node counting (tick:bool; top:bool) = (o:int) with var v: int in o = if tick then v else 0 -> pre o + v and v = if top then 1 else 0 12

13 13 N-ary Merge merge combines two complementary flows (flows on complementary clocks) to produce a faster one:.. a2 a1 a3 Merge.. b7 b6 b5 b4 b3 b2 b1 a3 a2 a1.. b7 b6 b5 b4 b3 b2 b1 Originaly introduced in Lucid Synchrone (1996), now in SCADE 6 Example: merge c (a when c) (b whenot c) Generalization: can be generalized to n inputs with a specific extension of clocks with enumerated types the sampling e when c is now written e when True(c) the semantics extends naturally and we know how to compile it efficiently thus, a good basic for compilation

14 14 Reseting a behavior in Lustre, the reset behavior of an operator must be explicitely designed with a specific reset input node count() returns (s:int); let s = 0 fby s + 1 tel; node resetable_counter(r:bool) returns (s:int); let s = if r then 0 else 0 fby s + 1; tel; painful to apply on large model propose a primitive that applies on node instance and allow to reset it

15 15 Modularity and reset Specific notation in the basic calculus: f (a 1,..., a n ) every c all the node instances used in the definition of node f are reset when c is true the reset is asynchronous : no clock constraint between the condition c and the clock of the node instance is-it a primitive construct? yes and no modular translation of the basic language with reset into the basic language without reset ([PPDP00], with G. Hamon) essentially a translation of the initialization operator -> e 1 -> e 2 becomes if c then e 1 else e 2 very demanding to the code generator whereas it is trivial to compile! useful translation for verification tools, basic for compilation thus, a good basic for compilation

16 16 Translation Normalization Annotated CDK Annotated CDK (normalized) data flow transformations (CSE, Constant Prop.) Inlining Local Transformation + (naive to clever) scheduling ObjBasedLanguage EmitC Structured C

17 17 Putting Equations in Normal Form prepare equations before the translation extract delays from nested expressions by a linear traversal equations are transformed such that delays are extracted from nested computation. Normal Form: a ::= e ck e ::= a when C(x) op (a,..., a) x v ce ::= merge x (C ca)... (C ca) e ca ::= ce ck eq ::= x = ca x = (v fby a) ck (x,..., x) = (f (a,..., a) every x) ck D ::= D and D eq

18 18 Example is rewritten into: ck on True(c) z = ((((4 fby o) 3) when True(c)) + k) and o = (merge c (True (5 fby (z + 1)) + 2) (False ((6 fby x)) when False(c))) ck ck on True(c) z = (((t 1 3) when True(c)) + k) and o = (merge c (True t 2 + 2) and t 1 = (4 fby o) ck (False t 3 when False(c))) ck ck on True(c) and t 2 = (5 fby (z + 1)) and t 3 = (6 fby x) ck

19 19 Intermediate Language d ::= class f = memory m, instances j, reset() returns () = S, step (p) returns (p) = var p in S S ::= x := c state (x) := c S ; S skip o.reset (x,..., x) = o.step (c,..., c) case (x) {C : S;...; C : S} c ::= x v state (x) op(c,..., c) v ::= C i j ::= o : f,..., o : f p, m ::= x : t,..., x : t

20 20 Intermediate Language the minimal need to represent transition functions we introduce an ad-hoc intermediate language to represent them it has an object-based flavor (with minimal expressiveness nonetheless) static allocation of states only it can be trivially translated into a imperative language we only need a subset set of C (functions and static allocation of structures, very simple pointer manipulation)

21 21 Principles of the translation hierarchical memory model which corresponds to the call graph: one local memory for each function call every function defines a machine (a class ) the translation is made by a linear traversal of the sequence of normalized and scheduled equations control-structure (invariant): a computation on clock ck is executed when ck is true a guarded equations x = e ck translates into a control-structure E.g., the equation: x = (y + 2) base on C 1(x 1 ) on C 2 (x 2 ) is translated into a piece of control-structure: case (x 1 ) {C 1 : case (x 2 ) {C 2 : x = y + 2}}

22 22 Clock-directed code generation local generation of a control-structure from a clock merge them locally Control(base, S) = S Control(ck on C(x), S) = Control(ck, case (x) {C : S}) Join( case (x) {C 1 : S 1 ;...; C n : S n }, case (x) {C 1 : S 1 ;...; C n : S n}) = case (x) {C 1 : Join(S 1, S 1 );...; C n : Join(S n, S n)} Join(S 1, S 2 ) = S 1 ; S 2 control-optimization: find a static schedule of the equations which gather equations guarded by related clocks

23 23 Example (modularity) each function is compiled separately a function call needs a local memory node count(x:int) returns (o:int) let o = 0 fby o + x; tel node condact(c:bool;input:int) returns (o:int) var v: int; let v = count(input when true(c)); o = merge c (true -> v) (false -> (0 fby o) when false(c)); tel

24 24 class condact { x_2 : int; x_4 : count; reset() { x_4.reset(); mem x_2 = 0; } step(c : bool; input : int) returns (o : int) { x_3 : int; switch (c) { case true : (x_3) = x_4.step(input); o = x_3; case false : o = mem(x_2); }; mem x_2 = o; }

25 25 MiniLustre in Numbers Administrative code Abstract syntax + printers 546 Lexer&Parser 335 main (misc, symbol tables, loader) 285 Basis graph 74 scheduling 67 type checking 269 clock checking 190 causality check 30 normalization 95 translate (to ob) 136 Emitters to concrete languages (C, Java and Caml) arround 300 each Optimizations Inline + reset 250 Dead-code Removal 42 Data-flow network minimization 162

26 26 Extensions (towards a full language) Purely DataFlow Language + automata, signals, loop iteration, richer clocks, etc. Clocked DataFlow Language extend the source language with new programming constructs translation semantics into the basic data-flow language this is essentially the approach taken in Lucid Synchrone and the ReLuC compiler of SCADE clocks play a central role simple and gives very good code reuse of the existing code generator (adequate in the context of a certification process)

27 27 Formal Certification (Coq development) In parallel, we have implemented MiniLustre in the programming language of Coq + parts in Caml some part are directly programmed in Coq (2000 loc): E.g., translation function, checking clock/type annotation others (administrative) or less structural (e.g., scheduling) kept in Caml type and clock inference also done (4000 loc of Coq) The semantics of the source and target with proof of equivalence between the two are done on paper (one year to find the adequate combination). Proofs in Coq are under way

28 28 Conclusion Results a minimal description of modular code-generation formalize and simplifies the compilation techniques we have developped for the ReLuC compiler (with Esterel-Technologies) used for SCADE 6 Current Coq development of the semantics preservation finish the Coq programming of the reference compiler (combines translation validation, e.g., for the clever scheduling of equations) and certified compilation) Future (longer term) mixed systems (data-flow systems + mode-automata) source-to-source transformation into the data-flow system translation semantics (as done in ReLuC [EMSOFT 05, EMSOFT 06])

### An Eect Type System for Modular Distribution of Dataow Programs

An Eect Type System for Modular Distribution of Dataow Programs Gwenaël Delaval 1 Alain Girault 1 Marc Pouzet 2 P P 1 INRIA Rhône-Alpes, Pop-Art project ART 2 LRI, Demons team June 13, 2008 LCTES, Tucson,

### Automatic Code Generation from Stateflow Models

Automatic Code Generation from Stateflow Models Andres Toom IB Krates OÜ / Institute of Cybernetics at TUT Based on the Master s Thesis 05.2007 Supervisors: Tõnu Näks, Tarmo Uustalu TUT Department of Computer

Using SCADE to Develop Mission-critical High-quality Radar Application Software Bernard Dion and Aubanel Monnier Esterel Technologies, Parc Euclide 8 rue Blaise Pascal, F-78990, Elancourt, France bernard.dion@esterel-technologies.com

Simulink/Stateflow Paul Caspi http://www-verimag.imag.fr/ Pieter Mosterman http://www.mathworks.com/ June 2008 1 Introduction Probably, the early designers of Simulink in the late eighties would have been

### An Introduction to Lustre

An Introduction to Lustre Marc Pouzet École normale supérieure Marc.Pouzet@ens.fr MPRI, September 12, 2017 1 / 35 The language Lustre Invented by Paul Caspi and Nicolas Halbwachs arround 1984, in Grenoble

### INTEGRATING SYSTEM AND SOFTWARE ENGINEERING FOR CERTIFIABLE AVIONICS APPLICATIONS

INTEGRATING SYSTEM AND SOFTWARE ENGINEERING FOR CERTIFIABLE AVIONICS APPLICATIONS Thierry Le Sergent Mathieu Viala Alain Le Guennec Frédéric Roméas thierry.lesergent@esterel-technologies.com mathieu.viala@esterel-technologies.com

### Combining Programming with Theorem Proving

Combining Programming with Theorem Proving Chiyan Chen and Hongwei Xi Boston University Programming with Theorem Proving p.1/27 Motivation for the Research To support advanced type systems for practical

### Efficient compilation of array iterators for Lustre

Replace this file with prentcsmacro.sty for your meeting, or with entcsmacro.sty for your meeting. Both can be found at the ENTCS Macro Home Page. Efficient compilation of array iterators for Lustre Lionel

### UML Profile for MARTE: Time Model and CCSL

UML Profile for MARTE: Time Model and CCSL Frédéric Mallet 1 Université Nice Sophia Antipolis, Aoste team INRIA/I3S, Sophia Antipolis, France Frederic.Mallet@unice.fr Abstract. This 90 minutes tutorial

### 3.4 Deduction and Evaluation: Tools Conditional-Equational Logic

3.4 Deduction and Evaluation: Tools 3.4.1 Conditional-Equational Logic The general definition of a formal specification from above was based on the existence of a precisely defined semantics for the syntax

### Coq, a formal proof development environment combining logic and programming. Hugo Herbelin

Coq, a formal proof development environment combining logic and programming Hugo Herbelin 1 Coq in a nutshell (http://coq.inria.fr) A logical formalism that embeds an executable typed programming language:

### Modal Models in Ptolemy

Modal Models in Ptolemy Edward A. Lee Stavros Tripakis UC Berkeley Workshop on Equation-Based Object-Oriented Modeling Languages and Tools 3rd International Workshop on Equation-Based Object-Oriented Modeling

### Deductive Program Verification with Why3, Past and Future

Deductive Program Verification with Why3, Past and Future Claude Marché ProofInUse Kick-Off Day February 2nd, 2015 A bit of history 1999: Jean-Christophe Filliâtre s PhD Thesis Proof of imperative programs,

### Static analysis and all that

Static analysis and all that Martin Steffen IfI UiO Spring 2014 uio Static analysis and all that Martin Steffen IfI UiO Spring 2014 uio Plan approx. 15 lectures, details see web-page flexible time-schedule,

### Formal Verification of MIX Programs

Formal Verification of MIX Programs Jean-Christophe Filliâtre CNRS LRI, Univ Paris-Sud, Orsay F-91405 INRIA Futurs, ProVal, Orsay F-91893 Abstract We introduce a methodology to formally verify MIX programs.

### Concurrent Models of Computation

Concurrent Models of Computation Edward A. Lee Robert S. Pepper Distinguished Professor, UC Berkeley EECS 219D Concurrent Models of Computation Fall 2011 Copyright 2009-2011, Edward A. Lee, All rights

### SpecC Methodology for High-Level Modeling

EDP 2002 9 th IEEE/DATC Electronic Design Processes Workshop SpecC Methodology for High-Level Modeling Rainer Dömer Daniel D. Gajski Andreas Gerstlauer Center for Embedded Computer Systems Universitiy

### Part II. Hoare Logic and Program Verification. Why specify programs? Specification and Verification. Code Verification. Why verify programs?

Part II. Hoare Logic and Program Verification Part II. Hoare Logic and Program Verification Dilian Gurov Props: Models: Specs: Method: Tool: safety of data manipulation source code logic assertions Hoare

### Static Program Analysis

Static Program Analysis Thomas Noll Software Modeling and Verification Group RWTH Aachen University https://moves.rwth-aachen.de/teaching/ss-18/spa/ Preliminaries Outline of Lecture 1 Preliminaries Introduction

### A Verification Approach for GALS Integration of Synchronous Components

GALS 2005 Preliminary Version A Verification Approach for GALS Integration of Synchronous Components F. Doucet, M. Menarini, I. H. Krüger and R. Gupta 1 Computer Science and Engineering University of California,

### SCADE System, a comprehensive toolset for smooth transition from Model-Based System Engineering to certified embedded control and display software

SCADE System, a comprehensive toolset for smooth transition from Model-Based System Engineering to certified embedded control and display software Thierry Le Sergent (Product Manager) Alain Le Guennec

### On Meaning Preservation of a Calculus of Records

On Meaning Preservation of a Calculus of Records Emily Christiansen and Elena Machkasova Computer Science Discipline University of Minnesota, Morris Morris, MN 56267 chri1101, elenam@morris.umn.edu Abstract

### FORC 3 ES. FMF October 10 th Contributors Forces 3: Pierre-Loïc Garoche, Thomas Loquen, Eric Noulard, Claire Pagetti, Clément Roos, Pierre Roux

FORC 3 ES Contributors Forces 3: Pierre-Loïc Garoche, Thomas Loquen, Eric Noulard, Claire Pagetti, Clément Roos, Pierre Roux FMF October 10 th 2017 1 Outline! Introduction 1. Project description 2. Example

System-level co-modeling AADL and Simulink specifications using Polychrony (and Syndex) AADL Standards Meeting June 6., 2011 Jean-Pierre Talpin, INRIA Parts of this presentation are joint work with Paul,

### Applications of Formal Verification

Applications of Formal Verification Model Checking: Introduction to PROMELA Prof. Dr. Bernhard Beckert Dr. Vladimir Klebanov SS 2010 KIT INSTITUT FÜR THEORETISCHE INFORMATIK KIT University of the State

### Turning proof assistants into programming assistants

Turning proof assistants into programming assistants ST Winter Meeting, 3 Feb 2015 Magnus Myréen Why? Why combine proof- and programming assistants? Why proofs? Testing cannot show absence of bugs. Some

### A concrete memory model for CompCert

A concrete memory model for CompCert Frédéric Besson Sandrine Blazy Pierre Wilke Rennes, France P. Wilke A concrete memory model for CompCert 1 / 28 CompCert real-world C to ASM compiler used in industry

### A constructive denotational semantics for Kahn networks in Coq

A constructive denotational semantics for Kahn networks in oq hristine Paulin-Mohring INRIA Futurs, ProVal, Parc Orsay Université, F-91893 LRI, Univ Paris-Sud, NRS, Orsay, F-91405 July 18, 2007 Abstract

### Hybrid System Modeling: Operational Semantics Issues

Hybrid System Modeling: Operational Semantics Issues Edward A. Lee Professor UC Berkeley OMG Technical Meeting Feb. 4, 2004 Anaheim, CA, USA Special thanks to Jie Liu, Xiaojun Liu, Steve Neuendorffer,

### Defining and translating a safe subset of Simulink/Stateflow into Lustre

Unité Mixte de Recherche 5104 CNRS - INPG - UJF Centre Equation 2, avenue de VIGNATE F-38610 GIERES tel : +33 456 52 03 40 fax : +33 456 52 03 50 http://www-verimag.imag.fr Defining and translating a safe

### LusRegTes: A Regression Testing Tool for Lustre Programs

International Journal of Electrical and Computer Engineering (IJECE) Vol. 7, No. 5, October 2017, pp. 2635~2644 ISSN: 2088-8708, DOI: 10.11591/ijece.v7i5.pp2635-2644 2635 LusRegTes: A Regression Testing

### CSE 501: Compiler Construction. Course outline. Goals for language implementation. Why study compilers? Models of compilation

CSE 501: Compiler Construction Course outline Main focus: program analysis and transformation how to represent programs? how to analyze programs? what to analyze? how to transform programs? what transformations

### Synchronous Control and State Machines in Modelica

Synchronous Control and State Machines in Modelica Hilding Elmqvist Dassault Systèmes Sven Erik Mattsson, Fabien Gaucher, Francois Dupont Dassault Systèmes Martin Otter, Bernhard Thiele DLR Content Introduction

### Kind 2 User Documentation Version

Kind 2 User Documentation Version January 3, 2017 Contents Kind 2 3 Requirements..................................... 3 Building and installing................................ 4 Documentation....................................

### Type Checking and Type Equality

Type Checking and Type Equality Type systems are the biggest point of variation across programming languages. Even languages that look similar are often greatly different when it comes to their type systems.

### Programming Languages for Real-Time Systems. LS 12, TU Dortmund

Programming Languages for Real-Time Systems Prof. Dr. Jian-Jia Chen LS 12, TU Dortmund 20 June 2016 Prof. Dr. Jian-Jia Chen (LS 12, TU Dortmund) 1 / 41 References Slides are based on Prof. Wang Yi, Prof.

### A Deterministic Concurrent Language for Embedded Systems

A Deterministic Concurrent Language for Embedded Systems Stephen A. Edwards Columbia University Joint work with Olivier Tardieu SHIM:A Deterministic Concurrent Language for Embedded Systems p. 1/30 Definition

### Validating LR(1) parsers

Validating LR(1) parsers Jacques-Henri Jourdan François Pottier Xavier Leroy INRIA Paris-Rocquencourt, projet Gallium Journées LTP/MTVV, 2011-10-28 Parsing: recap text or token stream abstract syntax tree

### Timing Analysis Enhancement for Synchronous Program

Timing Analysis Enhancement for Synchronous Program Extended Abstract Pascal Raymond, Claire Maiza, Catherine Parent-Vigouroux, Fabienne Carrier, and Mihail Asavoae Grenoble-Alpes University Verimag, Centre

### Seminar Software Quality and Safety

Seminar Software Quality and Safety SCADE a model-driven Software Development Environment by Dominik Protte Software Engineering Group Universität Paderborn Motivation Many safety-critical components in

### Program certification with computational

Program certification with computational effects Burak Ekici j.w.w. Jean-Guillaume Dumas, Dominique Duval, Damien Pous y LJK, University Joseph Fourier, Grenoble y LIP, ENS-Lyon November 5, 2014 JNCF 14,

### Understanding and Verifying JavaScript Programs

Understanding and Verifying JavaScript Programs Philippa Gardner Imperial College London LFCS 30th Anniversary 1/31 JavaScript at Imperial Philippa Gardner José Fragoso Santos Petar Maksimović Daiva Naudˇziūnienė

### Program Static Analysis. Overview

Program Static Analysis Overview Program static analysis Abstract interpretation Data flow analysis Intra-procedural Inter-procedural 2 1 What is static analysis? The analysis to understand computer software

### The Pig Experience. A. Gates et al., VLDB 2009

The Pig Experience A. Gates et al., VLDB 2009 Why not Map-Reduce? Does not directly support complex N-Step dataflows All operations have to be expressed using MR primitives Lacks explicit support for processing

### Teleport Messaging for. Distributed Stream Programs

Teleport Messaging for 1 Distributed Stream Programs William Thies, Michal Karczmarek, Janis Sermulins, Rodric Rabbah and Saman Amarasinghe Massachusetts Institute of Technology PPoPP 2005 http://cag.lcs.mit.edu/streamit

### Towards a Module System for K

Towards a Module System for Mark Hills and Grigore Roşu {mhills, grosu}@cs.uiuc.edu Department of Computer Science University of Illinois at Urbana-Champaign WADT 08, 14 June 2008 Hills and Roşu WADT 08:

### Hardware-Software Codesign. 9. Worst Case Execution Time Analysis

Hardware-Software Codesign 9. Worst Case Execution Time Analysis Lothar Thiele 9-1 System Design Specification System Synthesis Estimation SW-Compilation Intellectual Prop. Code Instruction Set HW-Synthesis

### Static Program Analysis

Static Program Analysis Lecture 1: Introduction to Program Analysis Thomas Noll Lehrstuhl für Informatik 2 (Software Modeling and Verification) noll@cs.rwth-aachen.de http://moves.rwth-aachen.de/teaching/ws-1415/spa/

### Semantic Subtyping. Alain Frisch (ENS Paris) Giuseppe Castagna (ENS Paris) Véronique Benzaken (LRI U Paris Sud)

Semantic Subtyping Alain Frisch (ENS Paris) Giuseppe Castagna (ENS Paris) Véronique Benzaken (LRI U Paris Sud) http://www.cduce.org/ Semantic Subtyping - Groupe de travail BD LRI p.1/28 CDuce A functional

### Writing Evaluators MIF08. Laure Gonnord

Writing Evaluators MIF08 Laure Gonnord Laure.Gonnord@univ-lyon1.fr Evaluators, what for? Outline 1 Evaluators, what for? 2 Implementation Laure Gonnord (Lyon1/FST) Writing Evaluators 2 / 21 Evaluators,

### Concurrent Models of Computation

Chapter 5 Concurrent Models of Computation Contents 5.1 Structure of Models....................... 117 5.2 Synchronous-Reactive Models................. 118 Sidebar: Actor Networks as a System of Equations.......

### Computer Architecture: Dataflow/Systolic Arrays

Data Flow Computer Architecture: Dataflow/Systolic Arrays he models we have examined all assumed Instructions are fetched and retired in sequential, control flow order his is part of the Von-Neumann model

### Introduction to Functional Programming in Haskell 1 / 56

Introduction to Functional Programming in Haskell 1 / 56 Outline Why learn functional programming? The essence of functional programming What is a function? Equational reasoning First-order vs. higher-order

### Pretty-Big-Step Semantics

Pretty-Big-Step Semantics Arthur Charguéraud Inria Saclay Île-de-France & LRI, Université Paris Sud, CNRS arthur.chargueraud@inria.fr Abstract. In spite of the popularity of small-step semantics, big-step

### SCADE S E M I N A R I N S O F T W A R E E N G I N E E R I N G P R E S E N T E R A V N E R B A R R

SCADE 1 S E M I N A R I N S O F T W A R E E N G I N E E R I N G P R E S E N T E R A V N E R B A R R What is SCADE? Introduction 2 Software Critical Application Development Environment, a Lustrebased IDE

### Mode-Automata based Methodology for Scade

Mode-Automata based Methodology for Scade Ouassila Labbani, Jean-Luc Dekeyser, Pierre Boulet To cite this version: Ouassila Labbani, Jean-Luc Dekeyser, Pierre Boulet. Mode-Automata based Methodology for

### INFORMATION AND COMMUNICATION TECHNOLOGIES (ICT) PROGRAMME. Project FP7-ICT-2009-C CerCo. Report n. D2.2 Prototype implementation

INFORMATION AND COMMUNICATION TECHNOLOGIES (ICT) PROGRAMME Project FP7-ICT-2009-C-243881 CerCo Report n. D2.2 Prototype implementation Version 1.0 Main Authors: Nicolas Ayache, Roberto M. Amadio, Yann

### Balance between Formal and Informal Methods, Engineering and Artistry, Evolution and Rebuild

Balance between Formal and Informal Methods, Engineering and Artistry, Evolution and Rebuild Edward A. Lee, Professor, UC Berkeley, eal@eecs.berkeley.edu Technical Memorandum UCB/ERL M04/19 July 4, 2004

### Review. CS152: Programming Languages. Lecture 11 STLC Extensions and Related Topics. Let bindings (CBV) Adding Stuff. Booleans and Conditionals

Review CS152: Programming Languages Lecture 11 STLC Extensions and Related Topics e ::= λx. e x ee c v ::= λx. e c (λx. e) v e[v/x] e 1 e 2 e 1 e 2 τ ::= int τ τ Γ ::= Γ,x : τ e 2 e 2 ve 2 ve 2 e[e /x]:

### Functioning Hardware from Functional Specifications

Functioning Hardware from Functional Specifications Stephen A. Edwards Martha A. Kim Richard Townsend Kuangya Zhai Lianne Lairmore Columbia University IBM PL Day, November 18, 2014 Where s my 10 GHz processor?

### Register Allocation. Introduction Local Register Allocators

Register Allocation Introduction Local Register Allocators Copyright 2015, Pedro C. Diniz, all rights reserved. Students enrolled in the Compilers class at the University of Southern California have explicit

### Principles of Compiler Design

Principles of Compiler Design Intermediate Representation Compiler Lexical Analysis Syntax Analysis Semantic Analysis Source Program Token stream Abstract Syntax tree Unambiguous Program representation

### Widening Operator. Fixpoint Approximation with Widening. A widening operator 2 L ˆ L 7``! L is such that: Correctness: - 8x; y 2 L : (y) v (x y)

EXPERIENCE AN INTRODUCTION WITH THE DESIGN TOF A SPECIAL PURPOSE STATIC ANALYZER ABSTRACT INTERPRETATION P. Cousot Patrick.Cousot@ens.fr http://www.di.ens.fr/~cousot Biarritz IFIP-WG 2.3 2.4 meeting (1)

### A Modular Way to Reason About Iteration

A Modular Way to Reason About Iteration Jean-Christophe Filliâtre Mário Pereira LRI, Univ. Paris-Sud, CNRS, Inria Saclay INRIA Paris - Séminaire Gallium Mars 7, 2016 iteration iteration: hello old friend!

### Vector Clocks in Coq

Vector Clocks in Coq An Experience Report Christopher Meiklejohn Basho Technologies, Inc. Cambridge, MA 02139 cmeiklejohn@basho.com March 6, 2014 Outline of the talk Introduction Background Implementation

### Type Checking. Outline. General properties of type systems. Types in programming languages. Notation for type rules.

Outline Type Checking General properties of type systems Types in programming languages Notation for type rules Logical rules of inference Common type rules 2 Static Checking Refers to the compile-time

### Introduction to dependent types in Coq

October 24, 2008 basic use of the Coq system In Coq, you can play with simple values and functions. The basic command is called Check, to verify if an expression is well-formed and learn what is its type.

### Outline. General properties of type systems. Types in programming languages. Notation for type rules. Common type rules. Logical rules of inference

Type Checking Outline General properties of type systems Types in programming languages Notation for type rules Logical rules of inference Common type rules 2 Static Checking Refers to the compile-time

### Intro to semantics; Small-step semantics Lecture 1 Tuesday, January 29, 2013

Harvard School of Engineering and Applied Sciences CS 152: Programming Languages Lecture 1 Tuesday, January 29, 2013 1 Intro to semantics What is the meaning of a program? When we write a program, we use

### Intermediate representations IR #1: CPS/L 3. Code example. Advanced Compiler Construction Michel Schinz

Intermediate representations Intermediate representations Advanced Compiler Construction Michel Schinz 2016 03 03 The term intermediate representation (IR) or intermediate language designates the data-structure(s)

Contents About This Book...1 Chapter 1: Basic Concepts...5 Overview...6 SAS Programs...7 SAS Libraries...13 Referencing SAS Files...15 SAS Data Sets...18 Variable Attributes...21 Summary...26 Practice...28

### Principles of Programming Languages. Lecture Outline

Principles of Programming Languages CS 492 Lecture 1 Based on Notes by William Albritton 1 Lecture Outline Reasons for studying concepts of programming languages Programming domains Language evaluation

### CSC312 Principles of Programming Languages : Functional Programming Language. Copyright 2006 The McGraw-Hill Companies, Inc.

CSC312 Principles of Programming Languages : Functional Programming Language Overview of Functional Languages They emerged in the 1960 s with Lisp Functional programming mirrors mathematical functions:

### Utilizing Static Analysis for Programmable Logic Controllers

Sébastien Bornot Ralf Huuck Ben Lukoschus Lehrstuhl für Softwaretechnologie Universität Kiel Preußerstraße 1 9, D-24105 Kiel, Germany seb rhu bls @informatik.uni-kiel.de Yassine Lakhnech Verimag Centre

### Hierarchical Composition and Abstraction In Architecture Models

Hierarchical Composition and Abstraction In Architecture Models Pam Binns and Steve Vestal Honeywell Labs {pam.binns, steve.vestal}@honeywell.com Supported by the Air Force Office of Scientific Research

### Semantic Analysis. CSE 307 Principles of Programming Languages Stony Brook University

Semantic Analysis CSE 307 Principles of Programming Languages Stony Brook University http://www.cs.stonybrook.edu/~cse307 1 Role of Semantic Analysis Syntax vs. Semantics: syntax concerns the form of a

### G52CON: Concepts of Concurrency

G52CON: Concepts of Concurrency Lecture 4: Atomic Actions Natasha Alechina School of Computer Science nza@cs.nott.ac.uk Outline of the lecture process execution fine-grained atomic actions using fine-grained

### Using SCADE System for the Design and Integration of Critical Systems

11ATC-0290 Using SCADE System for the Design and Integration of Critical Systems Copyright 2011 SAE International ABSTRACT This paper presents the SCADE System product line for systems modeling and generation

### The Esterel language

Pascal Raymond, Verimag-CNRS Introduction 2 The first synchronous language (early 80 s) Gérard Berry and his team (École des Mines de Paris / INRIA Sophia-Antipolis) Imperative, sequential style (i.e.

### Building Synchronous DataFlow graphs with UML & MARTE/CCSL

Building Synchronous DataFlow graphs with UML & MARTE/CCSL F. Mallet, J. DeAntoni, C. André, R. de Simone Aoste - INRIA/I3S Université de Nice Sophia Antipolis UML & Formal methods Ambiguity and structural

### NOTES ON OBJECT-ORIENTED MODELING AND DESIGN

NOTES ON OBJECT-ORIENTED MODELING AND DESIGN Stephen W. Clyde Brigham Young University Provo, UT 86402 Abstract: A review of the Object Modeling Technique (OMT) is presented. OMT is an object-oriented

### Harvard School of Engineering and Applied Sciences CS 152: Programming Languages

Harvard School of Engineering and Applied Sciences CS 152: Programming Languages Lecture 14 Tuesday, March 24, 2015 1 Parametric polymorphism Polymorph means many forms. Polymorphism is the ability of

### Real-Time Embedded Software Modeling and Synthesis using Polychronous Data Flow Languages

Real-Time Embedded Software Modeling and Synthesis using Polychronous Data Flow Languages Matthew W. Kracht Thesis submitted to the Faculty of the Virginia Polytechnic Institute and State University in

### Programming Languages Third Edition. Chapter 9 Control I Expressions and Statements

Programming Languages Third Edition Chapter 9 Control I Expressions and Statements Objectives Understand expressions Understand conditional statements and guards Understand loops and variation on WHILE

### Representation Independence, Confinement and Access Control

Representation Independence, Confinement and Access Control Anindya Banerjee and David Naumann ab@cis.ksu.edu and naumann@cs.stevens-tech.edu Kansas State University and Stevens Institute of Technology

### Introduction 2 The first synchronous language (early 80 s) Gérard Berry and his team (École des Mines de Paris / INRIA Sophia-Antipolis) Imperative, s

Pascal Raymond, Verimag-CNRS Introduction 2 The first synchronous language (early 80 s) Gérard Berry and his team (École des Mines de Paris / INRIA Sophia-Antipolis) Imperative, sequential style (i.e.

### From Math to Machine A formal derivation of an executable Krivine Machine Wouter Swierstra Brouwer Seminar

From Math to Machine A formal derivation of an executable Krivine Machine Wouter Swierstra Brouwer Seminar β reduction (λx. t0) t1 t0 {t1/x} Substitution Realizing β-reduction through substitution is a

### these developments has been in the field of formal methods. Such methods, typically given by a

PCX: A Translation Tool from PROMELA/Spin to the C-Based Stochastic Petri et Language Abstract: Stochastic Petri ets (SPs) are a graphical tool for the formal description of systems with the features of

### Programming with Math and Logic

.. Programming with Math and Logic an invitation to functional programming Ed Morehouse Wesleyan University The Plan why fp? terms types interfaces The What and Why of Functional Programming Computing

### Boolean Representations and Combinatorial Equivalence

Chapter 2 Boolean Representations and Combinatorial Equivalence This chapter introduces different representations of Boolean functions. It then discusses the applications of these representations for proving

### Deductive Verification in Frama-C and SPARK2014: Past, Present and Future

Deductive Verification in Frama-C and SPARK2014: Past, Present and Future Claude Marché (Inria & Université Paris-Saclay) OSIS, Frama-C & SPARK day, May 30th, 2017 1 / 31 Outline Why this joint Frama-C

### Lecture 3 Notes Arrays

Lecture 3 Notes Arrays 15-122: Principles of Imperative Computation (Summer 1 2015) Frank Pfenning, André Platzer 1 Introduction So far we have seen how to process primitive data like integers in imperative

### Lecture Notes on Memory Layout

Lecture Notes on Memory Layout 15-122: Principles of Imperative Computation Frank Pfenning André Platzer Lecture 11 1 Introduction In order to understand how programs work, we can consider the functions,

### Programming Languages Fall 2014

Programming Languages Fall 2014 Lecture 7: Simple Types and Simply-Typed Lambda Calculus Prof. Liang Huang huang@qc.cs.cuny.edu 1 Types stuck terms? how to fix it? 2 Plan First I For today, we ll go back

### Programming Languages Fall 2013

Programming Languages Fall 2013 Lecture 7: Simple Types and Simply-Typed Lambda Calculus Prof. Liang Huang huang@qc.cs.cuny.edu Types stuck terms? how to fix it? Plan First I For today, we ll go back to

### CSE 3302 Notes 7: Control Abstraction

CSE 3302 Notes 7: Control Abstraction (Last updated 11/1/15 12:35 PM) References: Gabbrielli-Martini: 7; Dybvig: 5.5, 5.7 7.1. SUBPROGRAMS Interfacing Concepts: Parameters: Mathematics: Parameters Arguments

### Test and Evaluation of Autonomous Systems in a Model Based Engineering Context

Test and Evaluation of Autonomous Systems in a Model Based Engineering Context Raytheon Michael Nolan USAF AFRL Aaron Fifarek Jonathan Hoffman 3 March 2016 Copyright 2016. Unpublished Work. Raytheon Company.

### G COURSE PLAN ASSISTANT PROFESSOR Regulation: R13 FACULTY DETAILS: Department::

G COURSE PLAN FACULTY DETAILS: Name of the Faculty:: Designation: Department:: Abhay Kumar ASSOC PROFESSOR CSE COURSE DETAILS Name Of The Programme:: BTech Batch:: 2013 Designation:: ASSOC PROFESSOR Year