High Performance Relaying of C++11 Objects Across Processes and Logic-Labeled Finite-State Machines” Simpar2014

High PerformanceRelayingof
C++11Objects
acrossProcesses
and
Logic-Labeled
Finite-StateMachines
V. ESTIVILL-CASTRO*
*Griffith University, Nathan Campus,
Brisbane, Australia.
v.estivill-castrol@griffith.edu.au,
In collaboration with Rene Hexel, Carl Lusty and many other members of MiPal
(c)VladEstivill-Castro
1

Outline
• Two tools
• clfsm
• mipal gusimplewhiteboard
• What do they do?
• Finite-State Machines (FSM)
• Logic-labeled FSMs
• Examples
• What have they enabled
• software architectures /middleware
• Model-driven development
• Formal verification
• Conclusions
• What can I do so you would use them?
2

Outline
• Two tools
• clfsm
• Examples
• Conclusions
3

clfsm : compiled logic-labeled
finite-state machines
• Complete POSIX and C++11 compliance.
• Open source catkin ROS package release (mipal.net.au/downloads.php).
• Transitions are labeled by Boolean expressions (not events), facilitating formal verification
and eliminating all need for concerns about event queues.
• Transition labels are arbitrary C++11 Boolean expressions, enabling reasoning into what
may otherwise seem a purely reactive architecture.
• Handling of machines constructed with states that have UML 2.0 (or SCXML) OnEntry,
OnExit, and Internal sections with clear semantics.
• Guaranteed sequential ringlet schedule for the concurrent execution of FSMs (removing
the need for critical sections and synchronization points).
• Efficient execution as the entire arrangement runs as compiled code without thread
switching.
• Being agnostic to communication mechanisms between machines, allowing, for example
use with ROS:services and ROS:messages – however, we recommend the use of our
class-oriented gusimplewhiteboard.
• Mechanisms for sub-machine hierarchies and introspection to implement complex
behaviors. FSMs can be suspended, resumed, or restarted, as well as queried as to whether
they are running or not.
• Formal semantics that enables simulation, validation, and formal verification.
• Associated tools such as (MiEditLLFSM and MiCASE) that enable rapid development of
FSM arrangements.
• Tested in 64-bit, 32-bit CPUs and even 8-bit controllers like the Atmel AVR.
4

Outline
• Two tools
• clfsm
• Examples
• Conclusions
5

• Widely used model of behavior in embedded systems
• QP (Samek, 2008), Bot- Studio (Michel, 2004) StateWORKS (Wagner et al.,
2006) and MathWorks⃝R StateFlow. The UML form of FSMs derives from
OMT (Rumbaugh et al., 1991, Chapter 5), and the MDD initiatives of
Executable UML (Mellor and Balcer, 2002).
• The original Subsumption Architecture was implemented using the
Subsumption Language
• It was based on finite state machines (FSMs) augmented with
timers (AFSMs)
• AFSMs were implemented in Lisp
Finite-State Machines (FSM)
6

©V.Estivill-Castro
7
State Diagram /
Finite State Automaton
Motors forward Motors halted
For 0.1 sec
Light visible
Light
visible
Light NOT visible
Light NOT
visible
In UML,
events label
transitions

©V.Estivill-Castro
8
LabVIEW (short for Laboratory Virtual Instrument Engineering Workbench)
LEGO RoboLab

Robot control (philosophies)
• Open Loop Control
• Just carry on, don’t look at the environment
• Feedback control
• Minimize the error to the desired state
• Reactive Control
• Don’t think, (re)act.
• Deliberative (Planner-based/Logic -based) Control
• Think hard, act later.
• Hybrid Control
• Think and act separately & concurrently.
• Behavior-Based Control (BBC)
• Think the way you act.
9
No use of logic
no use of common sense
no intelligence?

How is a robot architecture
organized
10
From “Behavior-Based Robotics” by R. Arkin, MIT Press, 1998

Logic-labeled FSMs
• A second view of time (since Harel’s seminal paper)
• Machines are not waiting in the state for events
• The machines drive, execute
• The transitions are expressions in a logic
• or queries to an expert system
11
attack for a
bit
is the game over?
I am injured?
did the team lost possession?
are the fans misbehaving?

% BallConditions.d
name{BALLCONDITIONS}.
input{badProportionXY}.
input{badProportionYX}.
input{badDensityVsDensityTolerance}.
BC0: {} => is_it_a_ball.
BC1: badProportionXY => ~is_it_a_ball. BC1 > BC0.
BC2: badProportionYX => ~is_it_a_ball. BC2 > BC0.
BC3: badDensityVsDensityTolerance => ~is_it_a_ball. BC3 > BC0.
output{b is_it_a_ball, "is_it_a_ball"}.
Example from robotic soccer
12
Logic labeled FSMs provide deliverative control
Any C++11
code
Any C++11
Boolean
expression
(code)

Outline
• Two tools
• clfsm
• Examples
• Conclusions
13

Example 1: Pure reactive control
• https://www.youtube.com/watch?v=F8K4V78vUbk&feature=youtu.be
14

Example 2: BatMan moves
(reactive control on a Nao)
• https://www.youtube.com/watch?v=gN6rIveCWNk&feature=youtu.be
15

Example 2: BatMan moves
(reactive control on a Nao)
• https://www.youtube.com/watch?v=gN6rIveCWNk&feature=youtu.be
16

Example 3: Reactive control on ROS
• https://www.youtube.com/watch?v=AJYA2hB4i9U&feature=youtu.be
17

A turtle afraid of the walls
18

A turtle afraid of the walls
19

Example 4: Behavior Based
Control / Subsumption
Architecture
Mechanisms for sub-machine hierarchies and introspection to implement
complex behaviors. FSMs can be suspended, resumed, or restarted, as
well as queried as to whether they are running or not.
20

Example 5: RoboCup Game
Controller
21
Mechanisms for sub-machine hierarchies and introspection to implement
complex behaviors. FSMs can be suspended, resumed, or restarted, as
well as queried as to whether they are running or not.

clfsm : compiled logic-labeled
finite-state machines
• Complete POSIX and C++11 compliance.
• Open source catkin ROS package release (mipal.net.au/downloads.php).
• Transitions are labeled by Boolean expressions (not events), facilitating formal verification
and eliminating all need for concerns about event queues.
• Transition labels are arbitrary C++11 Boolean expressions, enabling reasoning into what
may otherwise seem a purely reactive architecture.
• Handling of machines constructed with states that have UML 2.0 (or SCXML) OnEntry,
OnExit, and Internal sections with clear semantics.
• Guaranteed sequential ringlet schedule for the concurrent execution of FSMs (removing
the need for critical sections and synchronization points).
• Efficient execution as the entire arrangement runs as compiled code without thread
switching.
• Being agnostic to communication mechanisms between machines, allowing, for example
use with ROS:services and ROS:messages – however, we recommend the use of our
class-oriented gusimplewhiteboard.
• Mechanisms for sub-machine hierarchies and introspection to implement complex
behaviors. FSMs can be suspended, resumed, or restarted, as well as queried as to whether
they are running or not.
• Formal semantics that enables simulation, validation, and formal verification.
• Associated tools such as (MiEditLLFSM and MiCASE) that enable rapid development of
FSM arrangements.
• Tested in 64-bit, 32-bit CPUs, and even 8-bit controllers like the Atmel AVR.
22
SUMMARY

Outline
• Two tools
• clfsm
• Examples
• Conclusions
23

gusimplewhiteboard :In
memory OO-messages/classes
• Completely C++11 and POSIX compliant; thus, platform
independent: used on Mac OS X (Mountain Lion), LINUX
13.10, Aldebaran Nao 1.14.3, Webots 7.1, the Raspberry Pi
(www.raspberrypi.org), and Lego NXT.
• Released as a ROS:catkin package
(mipal.net.au/downloads.php).
• Extremely fast performance for add_Message and
get_Message, intra-process as well as inter-process.
• Completely OO-compliant. The classes that can be used are
not restricted, the full data-structure mechanisms of C++11
are available.
• Very clear semantics that removes lots of issues of
concurrency control.
24

Middleware - Architecture
• In robotics we need to integrate many pieces of software in
charge of different things
• Sensors
• Actuators
• Filtering the sensors
• Fusing the sensors
• Coordinating the actuators
• making the motors in an arm control the arm
• Perform tasks, make decision, plan, learn
• Communicate with others
©V.Estivill-Castro
25

Software Engineering concerns
• Modularity
• Integration
• Reliability/ Testing
• Development cycle
• Simulations
• Monitoring
©V.Estivill-Castro
26

Whiteboard/Blackboard
architecture
©V.Estivill-Castro
27
Reduce the number of APIs

Conceptual cycle
• Similar to a ‘reactive-architecture’
• Similar to a whiteboard architecture
28
w
h
i
h
e
b
o
a
r
d
sensor 1
sensor space of the robot
sensor 2
sensor 3
sensor 4
sensor n
CONTROL AT ITS OWN TIME
Do the right thing by the state
of the world
t
h
e
i
r
o
w
n
t
i
m
e
• Deliberative control
architecture by symbolic-
modeling systems (logics)
• Behavior-base control by
arrangements of FSMs

Modes of communication
• PULL (closer to time-triggered)
• receivers query the whiteboard for the latest from the sender
• own thread for the receiver
• sender just does and add message
• PUSH (closer to event-driven)
• the receivers subscribe a call-back in the whiteboard
• add message by sender spans new threads in the receivers
©V.Estivill-Castro
29
Whiteboard
Sender Receiver
Receiver
Receiver
Receiver

add_Message
• Includes
#include "gugenericwhiteboardobject.h"
#include "guwhiteboardtypelist_generated.h”
• Declare a handler
Ball_Belief_t wb_ball;
• Construct you objects (with the constructor of the OO-class)
Ball_Belief a_ball(50,30);
• Use the setter to actually post to the whiteboard
wb_ball.set(a_ball);
30

get_Message
• Includes
#include "gugenericwhiteboardobject.h"
#include "guwhiteboardtypelist_generated.h”
Ball_Belief_t wb_ball;
• Retrieve your object
Ball_Belief ball = wb_ball.get();
// or alternatively: ball = wb_ball();
31

Illustration of OO facility
32
• Retrieve an object and
its property
• Properties are objects

Speed
• Of the order of 50 times faster than ROS
• 2013 Mac Pro, 3 GHz 8-Core Intel Xeon E5, 32 GB memory
1867 MHz DDR3 ECC RAM
• Identical compiler flags (compiled with catkin_make)
33

One Minute Microwave
• Widely discussed in the literature
of software engineering
• Analogous to the X-Ray machine
• Therac-25 radiation machine that
caused harm to patients
• Important SAFETY feature
• OPENING THE DOOR SHALL STOP
THE COOKING
34

Requirements
35
Requirements Description
R1 There is a single control button available for the use of the oven. If the
oven is closed and you push the button, the oven will start cooking (that
is, energize the power-tube) for one minute
R2 If the button is pushed while the oven is cooking, it will cause the oven
to cook for an extra minute.
R3 Pushing the button when the door is open has no effect.
R4 Whenever the oven is cooking or the door is open, the light in the oven
will be on.
R5 Opening the door stops the cooking.
R6 Closing the door turns off the light. This is the normal idle state, prior to
cooking when the user has placed food in the oven.
R7 If the oven times out, the light and the power-tube are turned off and
then a beeper emits a warning beep to indicate that the cooking has
finished.
and does not clear the timer
and stops the timer

One of the FSMs
36
% MicrowaveCook.d
name{MicrowaveCook}.
input{timeLeft}.
input{doorOpen}.
C0: {} => ~cook.
C1: timeLeft => cook. C1 > C0.
C2: doorOpen => ~cook. C2 > C1.
output{b cook, "cook"}.

Embedded systems are
performing several things
• The models is made of several finite state-machines
• Behavior-based control
• With a rich language of logic, the modeling aspect is
decomposed
• the action /reaction part of the system
• the states and transitions of the finite-state machine
• the declarative knowledge of the world
• the logic system
37

The complete arrangement
38
2 OFF
OnEntry {int sound; sound=0;}
OnExit {}
{}
1 ARMED
OnEntry {}
OnExit {}
{}
timeLeft
timeout(2000000)
1 RINGING
OnEntry {sound=1;}
OnExit {}
{}
!timeLeft
2 NOT_COOKING
OnEntry {int motor; motor=0;}
OnExit {}
{}
1 COOKING
OnEntry {motor=1;}
OnExit {}
{}
!doorOpen && timeleft
doorOpen || ! timeLeft
2 NOT_SHINE_LIGHT
OnEntry {int light; light=0;}
OnExit {}
{}
1 SHINE_LIGHT
OnEntry {light=1;}
OnExit {}
{}
doorOpen || timeLeft
!doorOpen && ! timeLeft
1 INIT
OnEntry {int currentTime; extern buttonPushed;
extern doorOpen; currentTime=0;}
OnExit {}
{}
2 TEST
OnEntry
{timeLeft=0<currentTime;}
OnExit {}
{}
true
true
4 DECREMENT
OnEntry {currentTime=currentTime-1;}
OnExit {}
{}
buttonPushed && !doorOpen && (currentTime<4035)
3 ADD_60
OnEntry {currentTime=60+currentTime;}
OnExit {timeLeft=1;}
{}
!buttonPushed
!doorOpen && timeLeft && timeout(1000000)
Light
Motor
Bell
Timer
Execute in predefined
schedule ti ringlets
of FSM Mi
DPL
LOGIC IS COMPILED

Demo video
http://www.youtube.com/watch?v=t4ueI1o67Xk&feature=relmfu
40

Simulator (embedded system:
Industrial press)
41
http://www.youtube.com/watch?v=FpVUSrvLI0c&feature=relmfu

On-line debugging and
simulation
42

Outline
• Two tools
• clfsm
• Examples
• Conclusions
43

Regulate the number of
threads
clfsm SMGameController Safety_BatteryMonitor
SMFallManager SMButtonChest SMButtonLeftFoot
SMButtonRightFoot SMRobotPosition SMSayIP SMShutdown
clfsm SMSoundStartStop SMSoundWhistle SMSoundDemo
SMGetUp SMPlayer SMBallFollower SMKicker SMHeadScanner
SMBallSeeker SMReadyFromInitial SMReadyFromAnywhere
SMHeadBallTracker SMWalkScanner SMSeeker Color_Learner
SMHeadScannerGoal SMHeadGoalTracker SMGetCloseToGoal
SMSet SMFindGoalOnSpot SMGoalieSaver SMFindGoalOnSpot
SMLeapController SMTeleoperationController
SMTeleoperation SMTeleoperationHeadControl BatNaoMoves
StopMotionRecorder SMYouCannotCatchMe
clfsm gukalmanfilter
clfsm guUDPreceiver
44
One thread
Second thread
Third thread
Fourth thread

Very quick development of
behaviors
• Very rapidly produces
results
• Very rapidly we can trace
the observed behavior to
the code
• Very rapidly we have
building blocks that add
sophistication
• All the behaviors in one go
45

The two paradigms
• Event-triggered
• optimistic
• best-case, response
time
• can’t handle event-
showers
• not predictable
• not scalable
• repeat the verification
• Time-triggered
• pessimistic
• regular response time
• predictable
• scalable
46Kopetz, H.: “Should Responsive Systems be Event-Triggered or
Time- Triggered?”
IEICE Transactions on Information and Systems 76(11), 1325
(November 1993)

Check out
clfsm
47
Let us know what you think

Conceptual cycle
49
w
h
i
h
e
b
o
a
r
d
sensor 1
sensory space of the robot
sensor 2
sensor 3
sensor 4
sensor n
of the world
t
h
e
i
r
o
w
n
t
i
m
e
architecture by logics
• Behavior-base control
by vectors of FSMs
under one CPU
rate for the sensors

Conceptual cycle
50
w
h
i
h
e
b
o
a
r
d
sensor 1
sensor 2
sensor 3
sensor 4
sensor n
of the world
t
h
e
i
r
o
w
n
t
i
m
e
by vectors of FSMs
under one CPU
time t2

Conceptual cycle
51
w
h
i
h
e
b
o
a
r
d
sensor 1
sensor space of the robot
and memory is FINITE
sensor 2
sensor 3
sensor 4
sensor n
of the world
t
h
e
i
r
o
w
n
t
i
m
e
by vectors of FSMs
under one CPU
time t3

Conceptual cycle
52
w
h
i
h
e
b
o
a
r
d
sensor 1
and memory is FINITE
sensor 2
sensor 3
sensor 4
sensor n
of the world
t
h
e
i
r
o
w
n
t
i
m
e
by vectors of FSMs
under one CPU
time t3
FULL REACTIVE
DO THE RIGHT THING
FOR MEMORY AND
SENSOR SPACE

Conceptual cycle
53
under several CPU
w
h
i
h
e
b
o
a
r
d
sensor 1
sensor 2
sensor 3
sensor 4
sensor n
Do the right thing by the state of
the world
FULL REACTIVE
DO THE RIGHT THING
FOR MEMORY AND
SENSOR SPACE
w
h
i
h
e
b
o
a
r
d
sensor 1
sensor 2
sensor 3
sensor 4
sensor n
Do the right thing by the state of
the world
FULL REACTIVE
DO THE RIGHT THING
FOR MEMORY AND
SENSOR SPACE
sensor C1
sensor C2

High Performance Relaying of C++11 Objects Across Processes and Logic-Labeled Finite-State Machines” Simpar2014

More Related Content

Viewers also liked (15)

Similar to High Performance Relaying of C++11 Objects Across Processes and Logic-Labeled Finite-State Machines” Simpar2014 (20)

Recently uploaded (20)

High Performance Relaying of C++11 Objects Across Processes and Logic-Labeled Finite-State Machines” Simpar2014