esterel programming language
DESCRIPTION
Esterel Programming Language. Synchronous Programming Language: Reactive systems that interact continuously with their environment, at a speed imposed by the environment Imperative programming style: - PowerPoint PPT PresentationTRANSCRIPT
Esterel Programming
Language
Main Characteristics• Synchronous Programming Language:
• Reactive systems that interact continuously with their environment, at a speed imposed by the environment
• Imperative programming style:• A programming paradigm that describes computation in
terms of statements that change a program state. It defines a sequence of commands for the computer to perform.
• This is opposed to declarative programming which expresses what a program should do without saying how it should do it.
Development• Design Goals:
• A natural expression of control allowing instantaneous propagation of control
• Simple and intuitive way of modeling system design and physical reality
• Ideal usage for hardware system control
time
Execution instants
Input Input InputOutput Output Output
Development• 1984:
• Jean-Paul Marmorat and Jean-Paul Rigault were researchers in Control Theory and Computer Science at the Ecole des Mines de Paris. While attempting to design a robotic car, they become frustrated in their attempts to express control algorithms in a natural and powerful way.
• In response they invent an original, mathematically defined formal notation that allows them to control the car.
• First Esterel Compiler is made
Jean-Paul Marmorat Jean-Paul Rigault
Development• 1988:
• Gerard Berry develops formal semantics and a first generation of code generation and formal verification tools
• 1989:• Simulog, a French software company, develops a
prototype version of the Esterel toolset for commercial use (Esterel v3 with enhanced compiler).
• First Industrial use with AT&T Bell Labs, Dassault Aviation, and Bertin.
Gerard Berry
Development• 1991:
• Esterel v4 integrates a hardware compiler for use with FPGA’s
• 1999:• Esterel Technologies is launched as a spinoff of Simulog
and continues development• 2003:
• Esterel v7 launches adding improved program structures, arrays of signals, delayed emissions, and multi-lock support
• 2006:• Standardization process begun for IEEE approval
Applications
Characteristics• Multiform Notion of Time
• Physical time is replaced with the notion of order• Only the simultaneity and presence of events are
considered, thus physical time is ignored• Esterel describes a totally ordered sequence of logical
events, with an arbitrary number of events happening in each instant
• Events that happen with in the same instant are considered to occur simultaneously
• Two types of events:• Those that start and end in the same instant (which
is considered instantaneous execution)• Those that delay for a certain amount of cycles
Characteristics• Multiform Notion of Time
Characteristics• Primitive statements
nothing Terminates immediately with no other effect.
pause Blocks control flow in the current cycle for resumption in the next cycle.
p ; q Runs p until it terminates and then, in the same reaction, start q.
p || q Runs p and q in parallel
loop p end
Restart the body p as soon as it terminates. Every path through the loop body must contain at least one pause statement to avoid unbounded looping within a single reaction.
signal S in p end Declares a local signal.
emit SMake signal S present in the current instant. A signal is absent unless it is emitted.
present S then p else q end If signal S is present in the current instant, immediately run p, otherwise run q.
suspend p when S Suspends the execution of the body in instants where S is present.
trap T in p end Declare a labeled escape block.
exit T Jump to the end of the innermost T-labeled escape block.
Characteristics• Derived statements
Derived statement Expansion
halt loop pause endsustain s loop emit s; pause end
present s then p end present s then p else nothing end
await s trap T in loop pause; present s then exit T end end loop end
await immediate s trap T in loop present s then exit T end; pause end loop end
suspend p when immediate s suspend present s then pause end; p when s
abort p when (immediate) s trap T in suspend p when s; exit T || await (immediate) s; exit T; end
weak abort p when (immediate) s trap T in p; exit T || await (immediate) s; exit T; end
loop p each s loop abort p ; halt when s end loop
every (immediate) s do p end every await (immediate) s; loop p each s
Characteristics• Module Example:
“Wait until both A and B have occurred, then output O, unless the reset R occurs”
A B
B/0 A/O
AB/O
RR
R
module ABRO: input A, B, R; output O;
loop [ await A || await B ]; emit O each R
end module
Esterel programs built from modules
O
Each module has an interface of input and output signals
Characteristics• Simpler, Faster Code:
A B
B/0 A/O
AB/O
RR
Rmodule ABRO: input A, B, R; output O;
loop [ await A || await B ]; emit O each R
end module
O
switch(state){case 0: state=1; break;case 1: if(!R)if(A)if(B) {O=1;state=4;} else state=2; else if(B)state=3;break;case 2: if(R)state=1; else if(B){O=1;state=4;} break;case 3: if(R)state=1; else if(A){O=1;state=4;} break;case 4: if(R)state=1;break;}
Signals• Esterel Signals:
• Signals are the only means of communication• Two types:
• Non-valued contains not data, they either exist or don’t exist (think true/false)
• Valued also contains data in addition to the state of its existence
• Any process can read or write a signal, which are broadcast across the program
• The default status of signals is absent, and must be explicitly set to present using the “emit” statement
• Signals are transmitted instantaneously (visible immediately within the cycle it is transmitted)
• Signal coherency is maintained by enforcement that all writers occur before any readers do
Signals
A signal emitted in a cycle is visible immediately[ pause; emit A; pause; emit A|| pause; present A then emit B end]
AB
A
Cycles
Groups of statements separated by || run concurrently and terminate when all groups have terminated
[ emit A; pause; emit B;|| pause; emit C; pause; emit D];emit E
A BC
DE
Cycles
Signals • Processes can communicate back and forth in the same cycle
[ pause; emit A; present B then emit C end; pause; emit A|| pause; present A then emit B end]
ABC
A
Cycles
• Signals are the only way for concurrent processes to communicate• Esterel does have variables, but they cannot be shared• Signal coherence rules ensure deterministic behavior• Language semantics clearly defines who must communicate with whom when
Await Statement The await statement waits for a particular cycleawait S waits for the next cycle in which S is present
[ emit A ; pause ; pause; emit A|| await A; emit B]
A AB
Cycles
Await normally waits for a cycle before beginning to checkawait immediate also checks the initial cycle
[ emit A ; pause ; pause; emit A|| await immediate A; emit B]
AB
A
Cycles
Await Statement
Cycles
• Esterel has an infinite loop statement• Rule: loop body cannot terminate instantly it needs at least one pause, await, etc. Can’t do an infinite amount of work in a single cycleloop emit A; pause; pause; emit Bend
A BA
BA
BA
Instantaneous nature of loops plus await provide very powerful synchronization mechanismsloop await 60 Sec; emit Minend Sec Sec Sec Sec Sec Sec Sec
Min
1 2 3 4 5 59 60…
Cycles
Circuit Translation
RESET = R & !BOOTA_TRIGGER = A_OUT & !RESET A_THEN = A_TRIGGER & AA_ELSE = A_TRIGGER & !AA_TERM = A_THEN | ! A_TRIGGERA_IN = BOOT | RESET | A_ELSE B_TRIGGER = B_OUT & !RESETB_THEN = B_TRIGGER & BB_ELSE = B_TRIGGER & !BB_TERM = B_THEN | ! B_TRIGGERB_IN = BOOT | RESET | B_ELSEACTIVE = A_TRIGGER | B_TRIGGERO = A_TERM & B_TERM & ACTIVE
loop [ await A || await B ]; emit O; haltevery R
boot
R
A
O
Esterel: When Control is Essential
• Model of time gives programmer precise control• Concurrency convenient for specifying control systems• Completely deterministic
• Guaranteed: no need for locks, semaphores, etc.• Finite-state language
• Easy to analyze• Execution time predictable• Much easier to verify formally
• Amenable to implementation in both hardware and software
Esterel: When Control is Essential
• Finite-state nature of the language limits flexibility• No dynamic memory allocation• No dynamic creation of processes
• Virtually nonexistent support for handling data• Really suited for simple decision-dominated controllers• Synchronous model of time can lead to over-specification• Semantic challenges
• Avoiding causality violations often difficult• Difficult to compile
• Limited number of users, tools, etc.
Questions?